2 * Copyright © 2015 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
31 #include "meta-spirv.h"
34 anv_device_init_meta_clear_state(struct anv_device
*device
)
36 VkPipelineIaStateCreateInfo ia_create_info
= {
37 .sType
= VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
,
38 .topology
= VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
,
39 .primitiveRestartEnable
= false,
42 /* We don't use a vertex shader for clearing, but instead build and pass
43 * the VUEs directly to the rasterization backend.
45 VkShader fs
= GLSL_VK_SHADER(device
, FRAGMENT
,
54 VkPipelineShaderStageCreateInfo fs_create_info
= {
55 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
56 .pNext
= &ia_create_info
,
58 .stage
= VK_SHADER_STAGE_FRAGMENT
,
60 .linkConstBufferCount
= 0,
61 .pLinkConstBufferInfo
= NULL
,
62 .pSpecializationInfo
= NULL
66 /* We use instanced rendering to clear multiple render targets. We have two
67 * vertex buffers: the first vertex buffer holds per-vertex data and
68 * provides the vertices for the clear rectangle. The second one holds
69 * per-instance data, which consists of the VUE header (which selects the
70 * layer) and the color (Vulkan supports per-RT clear colors).
72 VkPipelineVertexInputStateCreateInfo vi_create_info
= {
73 .sType
= VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
,
74 .pNext
= &fs_create_info
,
76 .pVertexBindingDescriptions
= (VkVertexInputBindingDescription
[]) {
80 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
85 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_INSTANCE
89 .pVertexAttributeDescriptions
= (VkVertexInputAttributeDescription
[]) {
94 .format
= VK_FORMAT_R32G32B32A32_UINT
,
101 .format
= VK_FORMAT_R32G32_SFLOAT
,
108 .format
= VK_FORMAT_R32G32B32A32_SFLOAT
,
114 VkPipelineRsStateCreateInfo rs_create_info
= {
115 .sType
= VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
,
116 .pNext
= &vi_create_info
,
117 .depthClipEnable
= true,
118 .rasterizerDiscardEnable
= false,
119 .fillMode
= VK_FILL_MODE_SOLID
,
120 .cullMode
= VK_CULL_MODE_NONE
,
121 .frontFace
= VK_FRONT_FACE_CCW
124 VkPipelineCbStateCreateInfo cb_create_info
= {
125 .sType
= VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
,
126 .pNext
= &rs_create_info
,
127 .attachmentCount
= 1,
128 .pAttachments
= (VkPipelineCbAttachmentState
[]) {
129 { .channelWriteMask
= VK_CHANNEL_A_BIT
|
130 VK_CHANNEL_R_BIT
| VK_CHANNEL_G_BIT
| VK_CHANNEL_B_BIT
},
134 anv_pipeline_create((VkDevice
) device
,
135 &(VkGraphicsPipelineCreateInfo
) {
136 .sType
= VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
,
137 .pNext
= &cb_create_info
,
141 &(struct anv_pipeline_create_info
) {
142 .use_repclear
= true,
143 .disable_viewport
= true,
146 &device
->meta_state
.clear
.pipeline
);
148 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, fs
);
151 #define NUM_VB_USED 2
152 struct anv_saved_state
{
153 struct anv_vertex_binding old_vertex_bindings
[NUM_VB_USED
];
154 struct anv_descriptor_set
*old_descriptor_set0
;
155 struct anv_pipeline
*old_pipeline
;
156 VkDynamicCbState cb_state
;
160 anv_cmd_buffer_save(struct anv_cmd_buffer
*cmd_buffer
,
161 struct anv_saved_state
*state
)
163 state
->old_pipeline
= cmd_buffer
->pipeline
;
164 state
->old_descriptor_set0
= cmd_buffer
->descriptors
[0].set
;
165 memcpy(state
->old_vertex_bindings
, cmd_buffer
->vertex_bindings
,
166 sizeof(state
->old_vertex_bindings
));
170 anv_cmd_buffer_restore(struct anv_cmd_buffer
*cmd_buffer
,
171 const struct anv_saved_state
*state
)
173 cmd_buffer
->pipeline
= state
->old_pipeline
;
174 cmd_buffer
->descriptors
[0].set
= state
->old_descriptor_set0
;
175 memcpy(cmd_buffer
->vertex_bindings
, state
->old_vertex_bindings
,
176 sizeof(state
->old_vertex_bindings
));
178 cmd_buffer
->vb_dirty
|= (1 << NUM_VB_USED
) - 1;
179 cmd_buffer
->dirty
|= ANV_CMD_BUFFER_PIPELINE_DIRTY
;
180 cmd_buffer
->descriptors_dirty
|= VK_SHADER_STAGE_VERTEX_BIT
;
186 uint32_t ViewportIndex
;
190 struct clear_instance_data
{
191 struct vue_header vue_header
;
192 VkClearColorValue color
;
196 meta_emit_clear(struct anv_cmd_buffer
*cmd_buffer
,
198 struct clear_instance_data
*instance_data
)
200 struct anv_device
*device
= cmd_buffer
->device
;
201 struct anv_framebuffer
*fb
= cmd_buffer
->framebuffer
;
202 struct anv_state state
;
205 const float vertex_data
[] = {
206 /* Rect-list coordinates */
209 fb
->width
, fb
->height
,
211 /* Align to 16 bytes */
215 size
= sizeof(vertex_data
) + num_instances
* sizeof(*instance_data
);
216 state
= anv_state_stream_alloc(&cmd_buffer
->surface_state_stream
, size
, 16);
218 /* Copy in the vertex and instance data */
219 memcpy(state
.map
, vertex_data
, sizeof(vertex_data
));
220 memcpy(state
.map
+ sizeof(vertex_data
), instance_data
,
221 num_instances
* sizeof(*instance_data
));
223 struct anv_buffer vertex_buffer
= {
224 .device
= cmd_buffer
->device
,
226 .bo
= &device
->surface_state_block_pool
.bo
,
227 .offset
= state
.offset
230 anv_CmdBindVertexBuffers((VkCmdBuffer
) cmd_buffer
, 0, 2,
232 (VkBuffer
) &vertex_buffer
,
233 (VkBuffer
) &vertex_buffer
240 if ((VkPipeline
) cmd_buffer
->pipeline
!= device
->meta_state
.clear
.pipeline
)
241 anv_CmdBindPipeline((VkCmdBuffer
) cmd_buffer
,
242 VK_PIPELINE_BIND_POINT_GRAPHICS
,
243 device
->meta_state
.clear
.pipeline
);
245 /* We don't need anything here, only set if not already set. */
246 if (cmd_buffer
->rs_state
== NULL
)
247 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
248 VK_STATE_BIND_POINT_RASTER
,
249 device
->meta_state
.shared
.rs_state
);
251 if (cmd_buffer
->vp_state
== NULL
)
252 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
253 VK_STATE_BIND_POINT_VIEWPORT
,
254 cmd_buffer
->framebuffer
->vp_state
);
256 if (cmd_buffer
->ds_state
== NULL
)
257 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
258 VK_STATE_BIND_POINT_DEPTH_STENCIL
,
259 device
->meta_state
.shared
.ds_state
);
261 if (cmd_buffer
->cb_state
== NULL
)
262 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
263 VK_STATE_BIND_POINT_COLOR_BLEND
,
264 device
->meta_state
.shared
.cb_state
);
266 anv_CmdDraw((VkCmdBuffer
) cmd_buffer
, 0, 3, 0, num_instances
);
270 anv_cmd_buffer_clear(struct anv_cmd_buffer
*cmd_buffer
,
271 struct anv_render_pass
*pass
)
273 struct anv_saved_state saved_state
;
275 int num_clear_layers
= 0;
276 struct clear_instance_data instance_data
[MAX_RTS
];
278 for (uint32_t i
= 0; i
< pass
->num_layers
; i
++) {
279 if (pass
->layers
[i
].color_load_op
== VK_ATTACHMENT_LOAD_OP_CLEAR
) {
280 instance_data
[num_clear_layers
++] = (struct clear_instance_data
) {
286 .color
= pass
->layers
[i
].clear_color
,
291 if (num_clear_layers
== 0)
294 anv_cmd_buffer_save(cmd_buffer
, &saved_state
);
296 meta_emit_clear(cmd_buffer
, num_clear_layers
, instance_data
);
298 /* Restore API state */
299 anv_cmd_buffer_restore(cmd_buffer
, &saved_state
);
303 anv_device_init_meta_blit_state(struct anv_device
*device
)
305 VkPipelineIaStateCreateInfo ia_create_info
= {
306 .sType
= VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
,
307 .topology
= VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
,
308 .primitiveRestartEnable
= false,
311 /* We don't use a vertex shader for clearing, but instead build and pass
312 * the VUEs directly to the rasterization backend. However, we do need
313 * to provide GLSL source for the vertex shader so that the compiler
314 * does not dead-code our inputs.
316 VkShader vs
= GLSL_VK_SHADER(device
, VERTEX
,
319 out vec4 v_tex_coord
;
322 v_tex_coord
= vec4(a_tex_coord
, 0, 1);
323 gl_Position
= vec4(a_pos
, 0, 1);
327 VkShader fs
= GLSL_VK_SHADER(device
, FRAGMENT
,
330 layout(set
= 0, binding
= 0) uniform sampler2D u_tex
;
333 f_color
= texture(u_tex
, v_tex_coord
.xy
);
337 VkPipelineShaderStageCreateInfo vs_create_info
= {
338 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
339 .pNext
= &ia_create_info
,
341 .stage
= VK_SHADER_STAGE_VERTEX
,
343 .linkConstBufferCount
= 0,
344 .pLinkConstBufferInfo
= NULL
,
345 .pSpecializationInfo
= NULL
349 VkPipelineShaderStageCreateInfo fs_create_info
= {
350 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
351 .pNext
= &vs_create_info
,
353 .stage
= VK_SHADER_STAGE_FRAGMENT
,
355 .linkConstBufferCount
= 0,
356 .pLinkConstBufferInfo
= NULL
,
357 .pSpecializationInfo
= NULL
361 VkPipelineVertexInputStateCreateInfo vi_create_info
= {
362 .sType
= VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO
,
363 .pNext
= &fs_create_info
,
365 .pVertexBindingDescriptions
= (VkVertexInputBindingDescription
[]) {
369 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
374 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
378 .pVertexAttributeDescriptions
= (VkVertexInputAttributeDescription
[]) {
383 .format
= VK_FORMAT_R32G32B32A32_UINT
,
390 .format
= VK_FORMAT_R32G32_SFLOAT
,
394 /* Texture Coordinate */
397 .format
= VK_FORMAT_R32G32_SFLOAT
,
403 VkDescriptorSetLayoutCreateInfo ds_layout_info
= {
404 .sType
= VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
,
406 .pBinding
= (VkDescriptorSetLayoutBinding
[]) {
408 .descriptorType
= VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
,
410 .stageFlags
= VK_SHADER_STAGE_FRAGMENT_BIT
,
411 .pImmutableSamplers
= NULL
415 anv_CreateDescriptorSetLayout((VkDevice
) device
, &ds_layout_info
,
416 &device
->meta_state
.blit
.ds_layout
);
418 anv_CreatePipelineLayout((VkDevice
) device
,
419 &(VkPipelineLayoutCreateInfo
) {
420 .sType
= VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
,
421 .descriptorSetCount
= 1,
422 .pSetLayouts
= &device
->meta_state
.blit
.ds_layout
,
424 &device
->meta_state
.blit
.pipeline_layout
);
426 VkPipelineRsStateCreateInfo rs_create_info
= {
427 .sType
= VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
,
428 .pNext
= &vi_create_info
,
429 .depthClipEnable
= true,
430 .rasterizerDiscardEnable
= false,
431 .fillMode
= VK_FILL_MODE_SOLID
,
432 .cullMode
= VK_CULL_MODE_NONE
,
433 .frontFace
= VK_FRONT_FACE_CCW
436 VkPipelineCbStateCreateInfo cb_create_info
= {
437 .sType
= VK_STRUCTURE_TYPE_PIPELINE_CB_STATE_CREATE_INFO
,
438 .pNext
= &rs_create_info
,
439 .attachmentCount
= 1,
440 .pAttachments
= (VkPipelineCbAttachmentState
[]) {
441 { .channelWriteMask
= VK_CHANNEL_A_BIT
|
442 VK_CHANNEL_R_BIT
| VK_CHANNEL_G_BIT
| VK_CHANNEL_B_BIT
},
446 VkGraphicsPipelineCreateInfo pipeline_info
= {
447 .sType
= VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
,
448 .pNext
= &cb_create_info
,
450 .layout
= device
->meta_state
.blit
.pipeline_layout
,
453 anv_pipeline_create((VkDevice
) device
, &pipeline_info
,
454 &(struct anv_pipeline_create_info
) {
455 .use_repclear
= false,
456 .disable_viewport
= true,
457 .disable_scissor
= true,
461 &device
->meta_state
.blit
.pipeline
);
463 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, vs
);
464 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, fs
);
468 meta_prepare_blit(struct anv_cmd_buffer
*cmd_buffer
,
469 struct anv_saved_state
*saved_state
)
471 struct anv_device
*device
= cmd_buffer
->device
;
473 anv_cmd_buffer_save(cmd_buffer
, saved_state
);
475 if ((VkPipeline
) cmd_buffer
->pipeline
!= device
->meta_state
.blit
.pipeline
)
476 anv_CmdBindPipeline((VkCmdBuffer
) cmd_buffer
,
477 VK_PIPELINE_BIND_POINT_GRAPHICS
,
478 device
->meta_state
.blit
.pipeline
);
480 /* We don't need anything here, only set if not already set. */
481 if (cmd_buffer
->rs_state
== NULL
)
482 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
483 VK_STATE_BIND_POINT_RASTER
,
484 device
->meta_state
.shared
.rs_state
);
485 if (cmd_buffer
->ds_state
== NULL
)
486 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
487 VK_STATE_BIND_POINT_DEPTH_STENCIL
,
488 device
->meta_state
.shared
.ds_state
);
490 saved_state
->cb_state
= (VkDynamicCbState
) cmd_buffer
->cb_state
;
491 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
492 VK_STATE_BIND_POINT_COLOR_BLEND
,
493 device
->meta_state
.shared
.cb_state
);
497 VkOffset3D src_offset
;
498 VkExtent3D src_extent
;
499 VkOffset3D dest_offset
;
500 VkExtent3D dest_extent
;
504 meta_emit_blit(struct anv_cmd_buffer
*cmd_buffer
,
505 struct anv_surface_view
*src
,
506 VkOffset3D src_offset
,
507 VkExtent3D src_extent
,
508 struct anv_surface_view
*dest
,
509 VkOffset3D dest_offset
,
510 VkExtent3D dest_extent
)
512 struct anv_device
*device
= cmd_buffer
->device
;
514 struct blit_vb_data
{
519 unsigned vb_size
= sizeof(struct vue_header
) + 3 * sizeof(*vb_data
);
521 struct anv_state vb_state
=
522 anv_state_stream_alloc(&cmd_buffer
->surface_state_stream
, vb_size
, 16);
523 memset(vb_state
.map
, 0, sizeof(struct vue_header
));
524 vb_data
= vb_state
.map
+ sizeof(struct vue_header
);
526 vb_data
[0] = (struct blit_vb_data
) {
528 dest_offset
.x
+ dest_extent
.width
,
529 dest_offset
.y
+ dest_extent
.height
,
532 (float)(src_offset
.x
+ src_extent
.width
) / (float)src
->extent
.width
,
533 (float)(src_offset
.y
+ src_extent
.height
) / (float)src
->extent
.height
,
537 vb_data
[1] = (struct blit_vb_data
) {
540 dest_offset
.y
+ dest_extent
.height
,
543 (float)src_offset
.x
/ (float)src
->extent
.width
,
544 (float)(src_offset
.y
+ src_extent
.height
) / (float)src
->extent
.height
,
548 vb_data
[2] = (struct blit_vb_data
) {
554 (float)src_offset
.x
/ (float)src
->extent
.width
,
555 (float)src_offset
.y
/ (float)src
->extent
.height
,
559 struct anv_buffer vertex_buffer
= {
562 .bo
= &device
->surface_state_block_pool
.bo
,
563 .offset
= vb_state
.offset
,
566 anv_CmdBindVertexBuffers((VkCmdBuffer
) cmd_buffer
, 0, 2,
568 (VkBuffer
) &vertex_buffer
,
569 (VkBuffer
) &vertex_buffer
573 sizeof(struct vue_header
),
578 anv_AllocDescriptorSets((VkDevice
) device
, 0 /* pool */,
579 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT
,
580 1, &device
->meta_state
.blit
.ds_layout
, &set
, &count
);
581 anv_UpdateDescriptors((VkDevice
) device
, set
, 1,
584 .sType
= VK_STRUCTURE_TYPE_UPDATE_IMAGES
,
585 .descriptorType
= VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
,
588 .pImageViews
= (VkImageViewAttachInfo
[]) {
590 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
,
591 .view
= (VkImageView
) src
,
592 .layout
= VK_IMAGE_LAYOUT_GENERAL
,
598 struct anv_framebuffer
*fb
;
599 anv_CreateFramebuffer((VkDevice
) device
,
600 &(VkFramebufferCreateInfo
) {
601 .sType
= VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
,
602 .colorAttachmentCount
= 1,
603 .pColorAttachments
= (VkColorAttachmentBindInfo
[]) {
605 .view
= (VkColorAttachmentView
) dest
,
606 .layout
= VK_IMAGE_LAYOUT_GENERAL
609 .pDepthStencilAttachment
= NULL
,
611 .width
= dest
->extent
.width
,
612 .height
= dest
->extent
.height
,
614 }, (VkFramebuffer
*)&fb
);
618 anv_CreateRenderPass((VkDevice
)device
,
619 &(VkRenderPassCreateInfo
) {
620 .sType
= VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
,
621 .renderArea
= { { 0, 0 }, { dest
->extent
.width
, dest
->extent
.height
} },
622 .colorAttachmentCount
= 1,
626 .pColorFormats
= (VkFormat
[]) { dest
->format
},
627 .pColorLayouts
= (VkImageLayout
[]) { VK_IMAGE_LAYOUT_GENERAL
},
628 .pColorLoadOps
= (VkAttachmentLoadOp
[]) { VK_ATTACHMENT_LOAD_OP_LOAD
},
629 .pColorStoreOps
= (VkAttachmentStoreOp
[]) { VK_ATTACHMENT_STORE_OP_STORE
},
630 .pColorLoadClearValues
= (VkClearColorValue
[]) {
631 { .f32
= { 1.0, 0.0, 0.0, 1.0 } }
633 .depthStencilFormat
= VK_FORMAT_UNDEFINED
,
636 anv_CmdBeginRenderPass((VkCmdBuffer
) cmd_buffer
,
637 &(VkRenderPassBegin
) {
639 .framebuffer
= (VkFramebuffer
) fb
,
642 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
643 VK_STATE_BIND_POINT_VIEWPORT
, fb
->vp_state
);
645 anv_CmdBindDescriptorSets((VkCmdBuffer
) cmd_buffer
,
646 VK_PIPELINE_BIND_POINT_GRAPHICS
, 0, 1,
649 anv_CmdDraw((VkCmdBuffer
) cmd_buffer
, 0, 3, 0, 1);
651 anv_CmdEndRenderPass((VkCmdBuffer
) cmd_buffer
);
653 /* At the point where we emit the draw call, all data from the
654 * descriptor sets, etc. has been used. We are free to delete it.
656 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_DESCRIPTOR_SET
, set
);
657 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_FRAMEBUFFER
,
659 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_RENDER_PASS
, pass
);
663 meta_finish_blit(struct anv_cmd_buffer
*cmd_buffer
,
664 const struct anv_saved_state
*saved_state
)
666 anv_cmd_buffer_restore(cmd_buffer
, saved_state
);
667 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
668 VK_STATE_BIND_POINT_COLOR_BLEND
,
669 saved_state
->cb_state
);
673 vk_format_for_cpp(int cpp
)
676 case 1: return VK_FORMAT_R8_UINT
;
677 case 2: return VK_FORMAT_R8G8_UINT
;
678 case 3: return VK_FORMAT_R8G8B8_UINT
;
679 case 4: return VK_FORMAT_R8G8B8A8_UINT
;
680 case 6: return VK_FORMAT_R16G16B16_UINT
;
681 case 8: return VK_FORMAT_R16G16B16A16_UINT
;
682 case 12: return VK_FORMAT_R32G32B32_UINT
;
683 case 16: return VK_FORMAT_R32G32B32A32_UINT
;
685 unreachable("Invalid format cpp");
690 do_buffer_copy(struct anv_cmd_buffer
*cmd_buffer
,
691 struct anv_bo
*src
, uint64_t src_offset
,
692 struct anv_bo
*dest
, uint64_t dest_offset
,
693 int width
, int height
, VkFormat copy_format
)
695 VkDevice vk_device
= (VkDevice
)cmd_buffer
->device
;
697 VkImageCreateInfo image_info
= {
698 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
699 .imageType
= VK_IMAGE_TYPE_2D
,
700 .format
= copy_format
,
709 .tiling
= VK_IMAGE_TILING_LINEAR
,
710 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
714 struct anv_image
*src_image
, *dest_image
;
715 anv_CreateImage(vk_device
, &image_info
, (VkImage
*)&src_image
);
716 anv_CreateImage(vk_device
, &image_info
, (VkImage
*)&dest_image
);
718 /* We could use a vk call to bind memory, but that would require
719 * creating a dummy memory object etc. so there's really no point.
722 src_image
->offset
= src_offset
;
723 dest_image
->bo
= dest
;
724 dest_image
->offset
= dest_offset
;
726 struct anv_surface_view src_view
;
727 anv_image_view_init(&src_view
, cmd_buffer
->device
,
728 &(VkImageViewCreateInfo
) {
729 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
730 .image
= (VkImage
)src_image
,
731 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
732 .format
= copy_format
,
734 VK_CHANNEL_SWIZZLE_R
,
735 VK_CHANNEL_SWIZZLE_G
,
736 VK_CHANNEL_SWIZZLE_B
,
739 .subresourceRange
= {
740 .aspect
= VK_IMAGE_ASPECT_COLOR
,
750 struct anv_surface_view dest_view
;
751 anv_color_attachment_view_init(&dest_view
, cmd_buffer
->device
,
752 &(VkColorAttachmentViewCreateInfo
) {
753 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
754 .image
= (VkImage
)dest_image
,
755 .format
= copy_format
,
762 meta_emit_blit(cmd_buffer
,
764 (VkOffset3D
) { 0, 0, 0 },
765 (VkExtent3D
) { width
, height
, 1 },
767 (VkOffset3D
) { 0, 0, 0 },
768 (VkExtent3D
) { width
, height
, 1 });
770 anv_DestroyObject(vk_device
, VK_OBJECT_TYPE_IMAGE
, (VkImage
) src_image
);
771 anv_DestroyObject(vk_device
, VK_OBJECT_TYPE_IMAGE
, (VkImage
) dest_image
);
774 void anv_CmdCopyBuffer(
775 VkCmdBuffer cmdBuffer
,
778 uint32_t regionCount
,
779 const VkBufferCopy
* pRegions
)
781 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
782 struct anv_buffer
*src_buffer
= (struct anv_buffer
*)srcBuffer
;
783 struct anv_buffer
*dest_buffer
= (struct anv_buffer
*)destBuffer
;
784 struct anv_saved_state saved_state
;
786 meta_prepare_blit(cmd_buffer
, &saved_state
);
788 for (unsigned r
= 0; r
< regionCount
; r
++) {
789 uint64_t src_offset
= src_buffer
->offset
+ pRegions
[r
].srcOffset
;
790 uint64_t dest_offset
= dest_buffer
->offset
+ pRegions
[r
].destOffset
;
791 uint64_t copy_size
= pRegions
[r
].copySize
;
793 /* First, we compute the biggest format that can be used with the
794 * given offsets and size.
798 int fs
= ffs(src_offset
) - 1;
800 cpp
= MIN2(cpp
, 1 << fs
);
801 assert(src_offset
% cpp
== 0);
803 fs
= ffs(dest_offset
) - 1;
805 cpp
= MIN2(cpp
, 1 << fs
);
806 assert(dest_offset
% cpp
== 0);
808 fs
= ffs(pRegions
[r
].copySize
) - 1;
810 cpp
= MIN2(cpp
, 1 << fs
);
811 assert(pRegions
[r
].copySize
% cpp
== 0);
813 VkFormat copy_format
= vk_format_for_cpp(cpp
);
815 /* This is maximum possible width/height our HW can handle */
816 uint64_t max_surface_dim
= 1 << 14;
818 /* First, we make a bunch of max-sized copies */
819 uint64_t max_copy_size
= max_surface_dim
* max_surface_dim
* cpp
;
820 while (copy_size
> max_copy_size
) {
821 do_buffer_copy(cmd_buffer
, src_buffer
->bo
, src_offset
,
822 dest_buffer
->bo
, dest_offset
,
823 max_surface_dim
, max_surface_dim
, copy_format
);
824 copy_size
-= max_copy_size
;
825 src_offset
+= max_copy_size
;
826 dest_offset
+= max_copy_size
;
829 uint64_t height
= copy_size
/ (max_surface_dim
* cpp
);
830 assert(height
< max_surface_dim
);
832 uint64_t rect_copy_size
= height
* max_surface_dim
* cpp
;
833 do_buffer_copy(cmd_buffer
, src_buffer
->bo
, src_offset
,
834 dest_buffer
->bo
, dest_offset
,
835 max_surface_dim
, height
, copy_format
);
836 copy_size
-= rect_copy_size
;
837 src_offset
+= rect_copy_size
;
838 dest_offset
+= rect_copy_size
;
841 if (copy_size
!= 0) {
842 do_buffer_copy(cmd_buffer
, src_buffer
->bo
, src_offset
,
843 dest_buffer
->bo
, dest_offset
,
844 copy_size
/ cpp
, 1, copy_format
);
848 meta_finish_blit(cmd_buffer
, &saved_state
);
851 void anv_CmdCopyImage(
852 VkCmdBuffer cmdBuffer
,
854 VkImageLayout srcImageLayout
,
856 VkImageLayout destImageLayout
,
857 uint32_t regionCount
,
858 const VkImageCopy
* pRegions
)
860 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
861 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
862 struct anv_saved_state saved_state
;
864 meta_prepare_blit(cmd_buffer
, &saved_state
);
866 for (unsigned r
= 0; r
< regionCount
; r
++) {
867 struct anv_surface_view src_view
;
868 anv_image_view_init(&src_view
, cmd_buffer
->device
,
869 &(VkImageViewCreateInfo
) {
870 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
872 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
873 .format
= src_image
->format
,
875 VK_CHANNEL_SWIZZLE_R
,
876 VK_CHANNEL_SWIZZLE_G
,
877 VK_CHANNEL_SWIZZLE_B
,
880 .subresourceRange
= {
881 .aspect
= pRegions
[r
].srcSubresource
.aspect
,
882 .baseMipLevel
= pRegions
[r
].srcSubresource
.mipLevel
,
884 .baseArraySlice
= pRegions
[r
].srcSubresource
.arraySlice
,
891 struct anv_surface_view dest_view
;
892 anv_color_attachment_view_init(&dest_view
, cmd_buffer
->device
,
893 &(VkColorAttachmentViewCreateInfo
) {
894 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
896 .format
= src_image
->format
,
897 .mipLevel
= pRegions
[r
].destSubresource
.mipLevel
,
898 .baseArraySlice
= pRegions
[r
].destSubresource
.arraySlice
,
903 meta_emit_blit(cmd_buffer
,
905 pRegions
[r
].srcOffset
,
908 pRegions
[r
].destOffset
,
912 meta_finish_blit(cmd_buffer
, &saved_state
);
915 void anv_CmdBlitImage(
916 VkCmdBuffer cmdBuffer
,
918 VkImageLayout srcImageLayout
,
920 VkImageLayout destImageLayout
,
921 uint32_t regionCount
,
922 const VkImageBlit
* pRegions
)
924 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
925 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
926 struct anv_image
*dest_image
= (struct anv_image
*)destImage
;
927 struct anv_saved_state saved_state
;
929 meta_prepare_blit(cmd_buffer
, &saved_state
);
931 for (unsigned r
= 0; r
< regionCount
; r
++) {
932 struct anv_surface_view src_view
;
933 anv_image_view_init(&src_view
, cmd_buffer
->device
,
934 &(VkImageViewCreateInfo
) {
935 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
937 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
938 .format
= src_image
->format
,
940 VK_CHANNEL_SWIZZLE_R
,
941 VK_CHANNEL_SWIZZLE_G
,
942 VK_CHANNEL_SWIZZLE_B
,
945 .subresourceRange
= {
946 .aspect
= pRegions
[r
].srcSubresource
.aspect
,
947 .baseMipLevel
= pRegions
[r
].srcSubresource
.mipLevel
,
949 .baseArraySlice
= pRegions
[r
].srcSubresource
.arraySlice
,
956 struct anv_surface_view dest_view
;
957 anv_color_attachment_view_init(&dest_view
, cmd_buffer
->device
,
958 &(VkColorAttachmentViewCreateInfo
) {
959 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
961 .format
= dest_image
->format
,
962 .mipLevel
= pRegions
[r
].destSubresource
.mipLevel
,
963 .baseArraySlice
= pRegions
[r
].destSubresource
.arraySlice
,
968 meta_emit_blit(cmd_buffer
,
970 pRegions
[r
].srcOffset
,
971 pRegions
[r
].srcExtent
,
973 pRegions
[r
].destOffset
,
974 pRegions
[r
].destExtent
);
977 meta_finish_blit(cmd_buffer
, &saved_state
);
980 void anv_CmdCopyBufferToImage(
981 VkCmdBuffer cmdBuffer
,
984 VkImageLayout destImageLayout
,
985 uint32_t regionCount
,
986 const VkBufferImageCopy
* pRegions
)
988 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
989 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
990 struct anv_buffer
*src_buffer
= (struct anv_buffer
*)srcBuffer
;
991 struct anv_image
*dest_image
= (struct anv_image
*)destImage
;
992 struct anv_saved_state saved_state
;
994 meta_prepare_blit(cmd_buffer
, &saved_state
);
996 for (unsigned r
= 0; r
< regionCount
; r
++) {
997 struct anv_image
*src_image
;
998 anv_CreateImage(vk_device
,
999 &(VkImageCreateInfo
) {
1000 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
1001 .imageType
= VK_IMAGE_TYPE_2D
,
1002 .format
= dest_image
->format
,
1004 .width
= pRegions
[r
].imageExtent
.width
,
1005 .height
= pRegions
[r
].imageExtent
.height
,
1011 .tiling
= VK_IMAGE_TILING_LINEAR
,
1012 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
1014 }, (VkImage
*)&src_image
);
1016 /* We could use a vk call to bind memory, but that would require
1017 * creating a dummy memory object etc. so there's really no point.
1019 src_image
->bo
= src_buffer
->bo
;
1020 src_image
->offset
= src_buffer
->offset
+ pRegions
[r
].bufferOffset
;
1022 struct anv_surface_view src_view
;
1023 anv_image_view_init(&src_view
, cmd_buffer
->device
,
1024 &(VkImageViewCreateInfo
) {
1025 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
1026 .image
= (VkImage
)src_image
,
1027 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
1028 .format
= dest_image
->format
,
1030 VK_CHANNEL_SWIZZLE_R
,
1031 VK_CHANNEL_SWIZZLE_G
,
1032 VK_CHANNEL_SWIZZLE_B
,
1033 VK_CHANNEL_SWIZZLE_A
1035 .subresourceRange
= {
1036 .aspect
= pRegions
[r
].imageSubresource
.aspect
,
1039 .baseArraySlice
= 0,
1046 struct anv_surface_view dest_view
;
1047 anv_color_attachment_view_init(&dest_view
, cmd_buffer
->device
,
1048 &(VkColorAttachmentViewCreateInfo
) {
1049 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
1050 .image
= (VkImage
)dest_image
,
1051 .format
= dest_image
->format
,
1052 .mipLevel
= pRegions
[r
].imageSubresource
.mipLevel
,
1053 .baseArraySlice
= pRegions
[r
].imageSubresource
.arraySlice
,
1058 meta_emit_blit(cmd_buffer
,
1060 (VkOffset3D
) { 0, 0, 0 },
1061 pRegions
[r
].imageExtent
,
1063 pRegions
[r
].imageOffset
,
1064 pRegions
[r
].imageExtent
);
1066 anv_DestroyObject(vk_device
, VK_OBJECT_TYPE_IMAGE
, (VkImage
) src_image
);
1069 meta_finish_blit(cmd_buffer
, &saved_state
);
1072 void anv_CmdCopyImageToBuffer(
1073 VkCmdBuffer cmdBuffer
,
1075 VkImageLayout srcImageLayout
,
1076 VkBuffer destBuffer
,
1077 uint32_t regionCount
,
1078 const VkBufferImageCopy
* pRegions
)
1080 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
1081 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
1082 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
1083 struct anv_buffer
*dest_buffer
= (struct anv_buffer
*)destBuffer
;
1084 struct anv_saved_state saved_state
;
1086 meta_prepare_blit(cmd_buffer
, &saved_state
);
1088 for (unsigned r
= 0; r
< regionCount
; r
++) {
1089 struct anv_surface_view src_view
;
1090 anv_image_view_init(&src_view
, cmd_buffer
->device
,
1091 &(VkImageViewCreateInfo
) {
1092 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
1094 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
1095 .format
= src_image
->format
,
1097 VK_CHANNEL_SWIZZLE_R
,
1098 VK_CHANNEL_SWIZZLE_G
,
1099 VK_CHANNEL_SWIZZLE_B
,
1100 VK_CHANNEL_SWIZZLE_A
1102 .subresourceRange
= {
1103 .aspect
= pRegions
[r
].imageSubresource
.aspect
,
1104 .baseMipLevel
= pRegions
[r
].imageSubresource
.mipLevel
,
1106 .baseArraySlice
= pRegions
[r
].imageSubresource
.arraySlice
,
1113 struct anv_image
*dest_image
;
1114 anv_CreateImage(vk_device
,
1115 &(VkImageCreateInfo
) {
1116 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
1117 .imageType
= VK_IMAGE_TYPE_2D
,
1118 .format
= src_image
->format
,
1120 .width
= pRegions
[r
].imageExtent
.width
,
1121 .height
= pRegions
[r
].imageExtent
.height
,
1127 .tiling
= VK_IMAGE_TILING_LINEAR
,
1128 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
1130 }, (VkImage
*)&dest_image
);
1132 /* We could use a vk call to bind memory, but that would require
1133 * creating a dummy memory object etc. so there's really no point.
1135 dest_image
->bo
= dest_buffer
->bo
;
1136 dest_image
->offset
= dest_buffer
->offset
+ pRegions
[r
].bufferOffset
;
1138 struct anv_surface_view dest_view
;
1139 anv_color_attachment_view_init(&dest_view
, cmd_buffer
->device
,
1140 &(VkColorAttachmentViewCreateInfo
) {
1141 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
1142 .image
= (VkImage
)dest_image
,
1143 .format
= src_image
->format
,
1145 .baseArraySlice
= 0,
1150 meta_emit_blit(cmd_buffer
,
1152 pRegions
[r
].imageOffset
,
1153 pRegions
[r
].imageExtent
,
1155 (VkOffset3D
) { 0, 0, 0 },
1156 pRegions
[r
].imageExtent
);
1158 anv_DestroyObject(vk_device
, VK_OBJECT_TYPE_IMAGE
, (VkImage
) dest_image
);
1161 meta_finish_blit(cmd_buffer
, &saved_state
);
1164 void anv_CmdUpdateBuffer(
1165 VkCmdBuffer cmdBuffer
,
1166 VkBuffer destBuffer
,
1167 VkDeviceSize destOffset
,
1168 VkDeviceSize dataSize
,
1169 const uint32_t* pData
)
1174 void anv_CmdFillBuffer(
1175 VkCmdBuffer cmdBuffer
,
1176 VkBuffer destBuffer
,
1177 VkDeviceSize destOffset
,
1178 VkDeviceSize fillSize
,
1184 void anv_CmdClearColorImage(
1185 VkCmdBuffer cmdBuffer
,
1187 VkImageLayout imageLayout
,
1188 const VkClearColorValue
* pColor
,
1189 uint32_t rangeCount
,
1190 const VkImageSubresourceRange
* pRanges
)
1192 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
1193 struct anv_image
*image
= (struct anv_image
*)_image
;
1194 struct anv_saved_state saved_state
;
1196 anv_cmd_buffer_save(cmd_buffer
, &saved_state
);
1198 for (uint32_t r
= 0; r
< rangeCount
; r
++) {
1199 for (uint32_t l
= 0; l
< pRanges
[r
].mipLevels
; l
++) {
1200 for (uint32_t s
= 0; s
< pRanges
[r
].arraySize
; s
++) {
1201 struct anv_surface_view view
;
1202 anv_color_attachment_view_init(&view
, cmd_buffer
->device
,
1203 &(VkColorAttachmentViewCreateInfo
) {
1204 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
1206 .format
= image
->format
,
1207 .mipLevel
= pRanges
[r
].baseMipLevel
+ l
,
1208 .baseArraySlice
= pRanges
[r
].baseArraySlice
+ s
,
1214 anv_CreateFramebuffer((VkDevice
) cmd_buffer
->device
,
1215 &(VkFramebufferCreateInfo
) {
1216 .sType
= VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
,
1217 .colorAttachmentCount
= 1,
1218 .pColorAttachments
= (VkColorAttachmentBindInfo
[]) {
1220 .view
= (VkColorAttachmentView
) &view
,
1221 .layout
= VK_IMAGE_LAYOUT_GENERAL
1224 .pDepthStencilAttachment
= NULL
,
1226 .width
= view
.extent
.width
,
1227 .height
= view
.extent
.height
,
1232 anv_CreateRenderPass((VkDevice
) cmd_buffer
->device
,
1233 &(VkRenderPassCreateInfo
) {
1234 .sType
= VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
,
1235 .renderArea
= { { 0, 0 }, { view
.extent
.width
, view
.extent
.height
} },
1236 .colorAttachmentCount
= 1,
1240 .pColorFormats
= (VkFormat
[]) { image
->format
},
1241 .pColorLayouts
= (VkImageLayout
[]) { imageLayout
},
1242 .pColorLoadOps
= (VkAttachmentLoadOp
[]) { VK_ATTACHMENT_LOAD_OP_DONT_CARE
},
1243 .pColorStoreOps
= (VkAttachmentStoreOp
[]) { VK_ATTACHMENT_STORE_OP_STORE
},
1244 .pColorLoadClearValues
= pColor
,
1245 .depthStencilFormat
= VK_FORMAT_UNDEFINED
,
1248 anv_CmdBeginRenderPass((VkCmdBuffer
) cmd_buffer
,
1249 &(VkRenderPassBegin
) {
1251 .framebuffer
= (VkFramebuffer
) fb
,
1254 struct clear_instance_data instance_data
= {
1263 meta_emit_clear(cmd_buffer
, 1, &instance_data
);
1265 anv_CmdEndRenderPass((VkCmdBuffer
) cmd_buffer
);
1270 /* Restore API state */
1271 anv_cmd_buffer_restore(cmd_buffer
, &saved_state
);
1274 void anv_CmdClearDepthStencilImage(
1275 VkCmdBuffer cmdBuffer
,
1277 VkImageLayout imageLayout
,
1280 uint32_t rangeCount
,
1281 const VkImageSubresourceRange
* pRanges
)
1286 void anv_CmdClearColorAttachment(
1287 VkCmdBuffer cmdBuffer
,
1288 uint32_t colorAttachment
,
1289 VkImageLayout imageLayout
,
1290 const VkClearColorValue
* pColor
,
1292 const VkRect3D
* pRects
)
1297 void anv_CmdClearDepthStencilAttachment(
1298 VkCmdBuffer cmdBuffer
,
1299 VkImageAspectFlags imageAspectMask
,
1300 VkImageLayout imageLayout
,
1304 const VkRect3D
* pRects
)
1309 void anv_CmdResolveImage(
1310 VkCmdBuffer cmdBuffer
,
1312 VkImageLayout srcImageLayout
,
1314 VkImageLayout destImageLayout
,
1315 uint32_t regionCount
,
1316 const VkImageResolve
* pRegions
)
1322 anv_device_init_meta(struct anv_device
*device
)
1324 anv_device_init_meta_clear_state(device
);
1325 anv_device_init_meta_blit_state(device
);
1327 anv_CreateDynamicRasterState((VkDevice
) device
,
1328 &(VkDynamicRsStateCreateInfo
) {
1329 .sType
= VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
,
1331 &device
->meta_state
.shared
.rs_state
);
1333 anv_CreateDynamicColorBlendState((VkDevice
) device
,
1334 &(VkDynamicCbStateCreateInfo
) {
1335 .sType
= VK_STRUCTURE_TYPE_DYNAMIC_CB_STATE_CREATE_INFO
1337 &device
->meta_state
.shared
.cb_state
);
1339 anv_CreateDynamicDepthStencilState((VkDevice
) device
,
1340 &(VkDynamicDsStateCreateInfo
) {
1341 .sType
= VK_STRUCTURE_TYPE_DYNAMIC_DS_STATE_CREATE_INFO
1343 &device
->meta_state
.shared
.ds_state
);
1347 anv_device_finish_meta(struct anv_device
*device
)
1350 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_PIPELINE
,
1351 device
->meta_state
.clear
.pipeline
);
1354 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_PIPELINE
,
1355 device
->meta_state
.blit
.pipeline
);
1356 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_PIPELINE_LAYOUT
,
1357 device
->meta_state
.blit
.pipeline_layout
);
1358 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT
,
1359 device
->meta_state
.blit
.ds_layout
);
1362 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_DYNAMIC_RS_STATE
,
1363 device
->meta_state
.shared
.rs_state
);
1364 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_DYNAMIC_CB_STATE
,
1365 device
->meta_state
.shared
.cb_state
);
1366 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_DYNAMIC_DS_STATE
,
1367 device
->meta_state
.shared
.ds_state
);