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 "glsl_helpers.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 .disableVertexReuse
= false,
40 .primitiveRestartEnable
= false,
41 .primitiveRestartIndex
= 0
44 /* We don't use a vertex shader for clearing, but instead build and pass
45 * the VUEs directly to the rasterization backend.
47 VkShader fs
= GLSL_VK_SHADER(device
, FRAGMENT
,
56 VkPipelineShaderStageCreateInfo fs_create_info
= {
57 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
58 .pNext
= &ia_create_info
,
60 .stage
= VK_SHADER_STAGE_FRAGMENT
,
62 .linkConstBufferCount
= 0,
63 .pLinkConstBufferInfo
= NULL
,
64 .pSpecializationInfo
= NULL
68 /* We use instanced rendering to clear multiple render targets. We have two
69 * vertex buffers: the first vertex buffer holds per-vertex data and
70 * provides the vertices for the clear rectangle. The second one holds
71 * per-instance data, which consists of the VUE header (which selects the
72 * layer) and the color (Vulkan supports per-RT clear colors).
74 VkPipelineVertexInputCreateInfo vi_create_info
= {
75 .sType
= VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
,
76 .pNext
= &fs_create_info
,
78 .pVertexBindingDescriptions
= (VkVertexInputBindingDescription
[]) {
82 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
87 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_INSTANCE
91 .pVertexAttributeDescriptions
= (VkVertexInputAttributeDescription
[]) {
96 .format
= VK_FORMAT_R32G32B32A32_UINT
,
103 .format
= VK_FORMAT_R32G32_SFLOAT
,
110 .format
= VK_FORMAT_R32G32B32A32_SFLOAT
,
116 VkPipelineRsStateCreateInfo rs_create_info
= {
117 .sType
= VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
,
118 .pNext
= &vi_create_info
,
119 .depthClipEnable
= true,
120 .rasterizerDiscardEnable
= false,
121 .fillMode
= VK_FILL_MODE_SOLID
,
122 .cullMode
= VK_CULL_MODE_NONE
,
123 .frontFace
= VK_FRONT_FACE_CCW
126 anv_pipeline_create((VkDevice
) device
,
127 &(VkGraphicsPipelineCreateInfo
) {
128 .sType
= VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
,
129 .pNext
= &rs_create_info
,
133 &(struct anv_pipeline_create_info
) {
134 .use_repclear
= true,
135 .disable_viewport
= true,
138 &device
->clear_state
.pipeline
);
140 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, fs
);
142 anv_CreateDynamicRasterState((VkDevice
) device
,
143 &(VkDynamicRsStateCreateInfo
) {
144 .sType
= VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
,
146 &device
->clear_state
.rs_state
);
149 #define NUM_VB_USED 2
150 struct anv_saved_state
{
151 struct anv_bindings bindings
;
152 struct anv_bindings
*old_bindings
;
153 struct anv_pipeline
*old_pipeline
;
157 anv_cmd_buffer_save(struct anv_cmd_buffer
*cmd_buffer
,
158 struct anv_saved_state
*state
)
160 state
->old_bindings
= cmd_buffer
->bindings
;
161 cmd_buffer
->bindings
= &state
->bindings
;
162 state
->old_pipeline
= cmd_buffer
->pipeline
;
164 /* Initialize render targets for the meta bindings. */
165 anv_cmd_buffer_fill_render_targets(cmd_buffer
);
169 anv_cmd_buffer_restore(struct anv_cmd_buffer
*cmd_buffer
,
170 const struct anv_saved_state
*state
)
172 cmd_buffer
->bindings
= state
->old_bindings
;
173 cmd_buffer
->pipeline
= state
->old_pipeline
;
175 cmd_buffer
->vb_dirty
|= (1 << NUM_VB_USED
) - 1;
176 cmd_buffer
->dirty
|= ANV_CMD_BUFFER_PIPELINE_DIRTY
|
177 ANV_CMD_BUFFER_DESCRIPTOR_SET_DIRTY
;
183 uint32_t ViewportIndex
;
188 anv_cmd_buffer_clear(struct anv_cmd_buffer
*cmd_buffer
,
189 struct anv_render_pass
*pass
)
191 struct anv_device
*device
= cmd_buffer
->device
;
192 struct anv_framebuffer
*fb
= cmd_buffer
->framebuffer
;
193 struct anv_saved_state saved_state
;
194 struct anv_state state
;
197 struct instance_data
{
198 struct vue_header vue_header
;
202 if (pass
->num_clear_layers
== 0)
205 const float vertex_data
[] = {
206 /* Rect-list coordinates */
209 fb
->width
, fb
->height
,
211 /* Align to 16 bytes */
215 size
= sizeof(vertex_data
) + pass
->num_clear_layers
* sizeof(instance_data
[0]);
216 state
= anv_state_stream_alloc(&cmd_buffer
->surface_state_stream
, size
, 16);
218 memcpy(state
.map
, vertex_data
, sizeof(vertex_data
));
219 instance_data
= state
.map
+ sizeof(vertex_data
);
221 for (uint32_t i
= 0; i
< pass
->num_layers
; i
++) {
222 if (pass
->layers
[i
].color_load_op
== VK_ATTACHMENT_LOAD_OP_CLEAR
) {
223 *instance_data
++ = (struct instance_data
) {
230 pass
->layers
[i
].clear_color
.color
.floatColor
[0],
231 pass
->layers
[i
].clear_color
.color
.floatColor
[1],
232 pass
->layers
[i
].clear_color
.color
.floatColor
[2],
233 pass
->layers
[i
].clear_color
.color
.floatColor
[3],
239 struct anv_buffer vertex_buffer
= {
240 .device
= cmd_buffer
->device
,
242 .bo
= &device
->surface_state_block_pool
.bo
,
243 .offset
= state
.offset
246 anv_cmd_buffer_save(cmd_buffer
, &saved_state
);
248 anv_CmdBindVertexBuffers((VkCmdBuffer
) cmd_buffer
, 0, 2,
250 (VkBuffer
) &vertex_buffer
,
251 (VkBuffer
) &vertex_buffer
258 if ((VkPipeline
) cmd_buffer
->pipeline
!= device
->clear_state
.pipeline
)
259 anv_CmdBindPipeline((VkCmdBuffer
) cmd_buffer
,
260 VK_PIPELINE_BIND_POINT_GRAPHICS
, device
->clear_state
.pipeline
);
262 /* We don't need anything here, only set if not already set. */
263 if (cmd_buffer
->rs_state
== NULL
)
264 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
265 VK_STATE_BIND_POINT_RASTER
,
266 device
->clear_state
.rs_state
);
268 if (cmd_buffer
->vp_state
== NULL
)
269 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
270 VK_STATE_BIND_POINT_VIEWPORT
,
271 cmd_buffer
->framebuffer
->vp_state
);
273 anv_CmdDraw((VkCmdBuffer
) cmd_buffer
, 0, 3, 0, pass
->num_clear_layers
);
275 /* Restore API state */
276 anv_cmd_buffer_restore(cmd_buffer
, &saved_state
);
281 anv_device_init_meta_blit_state(struct anv_device
*device
)
283 VkPipelineIaStateCreateInfo ia_create_info
= {
284 .sType
= VK_STRUCTURE_TYPE_PIPELINE_IA_STATE_CREATE_INFO
,
285 .topology
= VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP
,
286 .disableVertexReuse
= false,
287 .primitiveRestartEnable
= false,
288 .primitiveRestartIndex
= 0
291 /* We don't use a vertex shader for clearing, but instead build and pass
292 * the VUEs directly to the rasterization backend. However, we do need
293 * to provide GLSL source for the vertex shader so that the compiler
294 * does not dead-code our inputs.
296 VkShader vs
= GLSL_VK_SHADER(device
, VERTEX
,
299 out vec4 v_tex_coord
;
302 v_tex_coord
= vec4(a_tex_coord
, 0, 1);
303 gl_Position
= vec4(a_pos
, 0, 1);
307 VkShader fs
= GLSL_VK_SHADER(device
, FRAGMENT
,
310 layout(set
= 0, index
= 0) uniform sampler2D u_tex
;
313 f_color
= texture2D(u_tex
, v_tex_coord
.xy
);
317 VkPipelineShaderStageCreateInfo vs_create_info
= {
318 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
319 .pNext
= &ia_create_info
,
321 .stage
= VK_SHADER_STAGE_VERTEX
,
323 .linkConstBufferCount
= 0,
324 .pLinkConstBufferInfo
= NULL
,
325 .pSpecializationInfo
= NULL
329 VkPipelineShaderStageCreateInfo fs_create_info
= {
330 .sType
= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
,
331 .pNext
= &vs_create_info
,
333 .stage
= VK_SHADER_STAGE_FRAGMENT
,
335 .linkConstBufferCount
= 0,
336 .pLinkConstBufferInfo
= NULL
,
337 .pSpecializationInfo
= NULL
341 VkPipelineVertexInputCreateInfo vi_create_info
= {
342 .sType
= VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO
,
343 .pNext
= &fs_create_info
,
345 .pVertexBindingDescriptions
= (VkVertexInputBindingDescription
[]) {
349 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
354 .stepRate
= VK_VERTEX_INPUT_STEP_RATE_VERTEX
358 .pVertexAttributeDescriptions
= (VkVertexInputAttributeDescription
[]) {
363 .format
= VK_FORMAT_R32G32B32A32_UINT
,
370 .format
= VK_FORMAT_R32G32_SFLOAT
,
374 /* Texture Coordinate */
377 .format
= VK_FORMAT_R32G32_SFLOAT
,
383 VkDescriptorSetLayoutCreateInfo ds_layout_info
= {
384 .sType
= VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO
,
386 .pBinding
= (VkDescriptorSetLayoutBinding
[]) {
388 .descriptorType
= VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
,
390 .stageFlags
= VK_SHADER_STAGE_FRAGMENT_BIT
,
391 .pImmutableSamplers
= NULL
395 anv_CreateDescriptorSetLayout((VkDevice
) device
, &ds_layout_info
,
396 &device
->blit_state
.ds_layout
);
398 VkPipelineLayoutCreateInfo pipeline_layout_info
= {
399 .sType
= VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
,
400 .descriptorSetCount
= 1,
401 .pSetLayouts
= &device
->blit_state
.ds_layout
,
404 VkPipelineLayout pipeline_layout
;
405 anv_CreatePipelineLayout((VkDevice
) device
, &pipeline_layout_info
,
408 VkPipelineRsStateCreateInfo rs_create_info
= {
409 .sType
= VK_STRUCTURE_TYPE_PIPELINE_RS_STATE_CREATE_INFO
,
410 .pNext
= &vi_create_info
,
411 .depthClipEnable
= true,
412 .rasterizerDiscardEnable
= false,
413 .fillMode
= VK_FILL_MODE_SOLID
,
414 .cullMode
= VK_CULL_MODE_NONE
,
415 .frontFace
= VK_FRONT_FACE_CCW
418 VkGraphicsPipelineCreateInfo pipeline_info
= {
419 .sType
= VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO
,
420 .pNext
= &rs_create_info
,
422 .layout
= pipeline_layout
,
425 anv_pipeline_create((VkDevice
) device
, &pipeline_info
,
426 &(struct anv_pipeline_create_info
) {
427 .use_repclear
= false,
428 .disable_viewport
= true,
429 .disable_scissor
= true,
433 &device
->blit_state
.pipeline
);
435 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, vs
);
436 anv_DestroyObject((VkDevice
) device
, VK_OBJECT_TYPE_SHADER
, fs
);
438 anv_CreateDynamicRasterState((VkDevice
) device
,
439 &(VkDynamicRsStateCreateInfo
) {
440 .sType
= VK_STRUCTURE_TYPE_DYNAMIC_RS_STATE_CREATE_INFO
,
442 &device
->blit_state
.rs_state
);
446 meta_prepare_blit(struct anv_cmd_buffer
*cmd_buffer
,
447 struct anv_saved_state
*saved_state
)
449 struct anv_device
*device
= cmd_buffer
->device
;
451 anv_cmd_buffer_save(cmd_buffer
, saved_state
);
453 if ((VkPipeline
) cmd_buffer
->pipeline
!= device
->blit_state
.pipeline
)
454 anv_CmdBindPipeline((VkCmdBuffer
) cmd_buffer
,
455 VK_PIPELINE_BIND_POINT_GRAPHICS
,
456 device
->blit_state
.pipeline
);
458 /* We don't need anything here, only set if not already set. */
459 if (cmd_buffer
->rs_state
== NULL
)
460 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
461 VK_STATE_BIND_POINT_RASTER
,
462 device
->blit_state
.rs_state
);
466 VkOffset3D src_offset
;
467 VkExtent3D src_extent
;
468 VkOffset3D dest_offset
;
469 VkExtent3D dest_extent
;
473 meta_emit_blit(struct anv_cmd_buffer
*cmd_buffer
,
474 struct anv_surface_view
*src
,
475 VkOffset3D src_offset
,
476 VkExtent3D src_extent
,
477 struct anv_surface_view
*dest
,
478 VkOffset3D dest_offset
,
479 VkExtent3D dest_extent
)
481 struct anv_device
*device
= cmd_buffer
->device
;
483 struct blit_vb_data
{
488 unsigned vb_size
= sizeof(struct vue_header
) + 3 * sizeof(*vb_data
);
490 struct anv_state vb_state
=
491 anv_state_stream_alloc(&cmd_buffer
->surface_state_stream
, vb_size
, 16);
492 memset(vb_state
.map
, 0, sizeof(struct vue_header
));
493 vb_data
= vb_state
.map
+ sizeof(struct vue_header
);
495 vb_data
[0] = (struct blit_vb_data
) {
497 dest_offset
.x
+ dest_extent
.width
,
498 dest_offset
.y
+ dest_extent
.height
,
501 (float)(src_offset
.x
+ src_extent
.width
) / (float)src
->extent
.width
,
502 (float)(src_offset
.y
+ src_extent
.height
) / (float)src
->extent
.height
,
506 vb_data
[1] = (struct blit_vb_data
) {
509 dest_offset
.y
+ dest_extent
.height
,
512 (float)src_offset
.x
/ (float)src
->extent
.width
,
513 (float)(src_offset
.y
+ src_extent
.height
) / (float)src
->extent
.height
,
517 vb_data
[2] = (struct blit_vb_data
) {
523 (float)src_offset
.x
/ (float)src
->extent
.width
,
524 (float)src_offset
.y
/ (float)src
->extent
.height
,
528 struct anv_buffer vertex_buffer
= {
531 .bo
= &device
->surface_state_block_pool
.bo
,
532 .offset
= vb_state
.offset
,
535 anv_CmdBindVertexBuffers((VkCmdBuffer
) cmd_buffer
, 0, 2,
537 (VkBuffer
) &vertex_buffer
,
538 (VkBuffer
) &vertex_buffer
542 sizeof(struct vue_header
),
547 anv_AllocDescriptorSets((VkDevice
) device
, 0 /* pool */,
548 VK_DESCRIPTOR_SET_USAGE_ONE_SHOT
,
549 1, &device
->blit_state
.ds_layout
, &set
, &count
);
550 anv_UpdateDescriptors((VkDevice
) device
, set
, 1,
553 .sType
= VK_STRUCTURE_TYPE_UPDATE_IMAGES
,
554 .descriptorType
= VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
,
557 .pImageViews
= (VkImageViewAttachInfo
[]) {
559 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO
,
560 .view
= (VkImageView
) src
,
561 .layout
= VK_IMAGE_LAYOUT_GENERAL
,
567 VkFramebufferCreateInfo fb_info
= {
568 .sType
= VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO
,
569 .colorAttachmentCount
= 1,
570 .pColorAttachments
= (VkColorAttachmentBindInfo
[]) {
572 .view
= (VkColorAttachmentView
) dest
,
573 .layout
= VK_IMAGE_LAYOUT_GENERAL
576 .pDepthStencilAttachment
= NULL
,
578 .width
= dest
->extent
.width
,
579 .height
= dest
->extent
.height
,
583 struct anv_framebuffer
*fb
;
584 anv_CreateFramebuffer((VkDevice
) device
, &fb_info
, (VkFramebuffer
*)&fb
);
586 VkRenderPassCreateInfo pass_info
= {
587 .sType
= VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO
,
588 .renderArea
= { { 0, 0 }, { dest
->extent
.width
, dest
->extent
.height
} },
589 .colorAttachmentCount
= 1,
593 .pColorFormats
= (VkFormat
[]) { dest
->format
},
594 .pColorLayouts
= (VkImageLayout
[]) { VK_IMAGE_LAYOUT_GENERAL
},
595 .pColorLoadOps
= (VkAttachmentLoadOp
[]) { VK_ATTACHMENT_LOAD_OP_LOAD
},
596 .pColorStoreOps
= (VkAttachmentStoreOp
[]) { VK_ATTACHMENT_STORE_OP_STORE
},
597 .pColorLoadClearValues
= (VkClearColor
[]) {
598 { .color
= { .floatColor
= { 1.0, 0.0, 0.0, 1.0 } }, .useRawValue
= false }
600 .depthStencilFormat
= VK_FORMAT_UNDEFINED
,
604 anv_CreateRenderPass((VkDevice
)device
, &pass_info
, &pass
);
606 anv_CmdBeginRenderPass((VkCmdBuffer
) cmd_buffer
,
607 &(VkRenderPassBegin
) {
609 .framebuffer
= (VkFramebuffer
) fb
,
612 anv_CmdBindDynamicStateObject((VkCmdBuffer
) cmd_buffer
,
613 VK_STATE_BIND_POINT_VIEWPORT
, fb
->vp_state
);
615 anv_CmdBindDescriptorSets((VkCmdBuffer
) cmd_buffer
,
616 VK_PIPELINE_BIND_POINT_GRAPHICS
, 0, 1,
619 anv_CmdDraw((VkCmdBuffer
) cmd_buffer
, 0, 3, 0, 1);
621 anv_CmdEndRenderPass((VkCmdBuffer
) cmd_buffer
, pass
);
625 meta_finish_blit(struct anv_cmd_buffer
*cmd_buffer
,
626 const struct anv_saved_state
*saved_state
)
628 anv_cmd_buffer_restore(cmd_buffer
, saved_state
);
631 void anv_CmdCopyBuffer(
632 VkCmdBuffer cmdBuffer
,
635 uint32_t regionCount
,
636 const VkBufferCopy
* pRegions
)
638 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
639 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
640 struct anv_buffer
*src_buffer
= (struct anv_buffer
*)srcBuffer
;
641 struct anv_buffer
*dest_buffer
= (struct anv_buffer
*)destBuffer
;
642 struct anv_saved_state saved_state
;
644 meta_prepare_blit(cmd_buffer
, &saved_state
);
646 for (unsigned r
= 0; r
< regionCount
; r
++) {
647 VkImageCreateInfo image_info
= {
648 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
649 .imageType
= VK_IMAGE_TYPE_2D
,
650 .format
= VK_FORMAT_R8_UNORM
,
652 .width
= pRegions
[r
].copySize
,
659 .tiling
= VK_IMAGE_TILING_LINEAR
,
660 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
664 struct anv_image
*src_image
, *dest_image
;
665 vkCreateImage(vk_device
, &image_info
, (VkImage
*)&src_image
);
666 vkCreateImage(vk_device
, &image_info
, (VkImage
*)&dest_image
);
668 /* We could use a vk call to bind memory, but that would require
669 * creating a dummy memory object etc. so there's really no point.
671 src_image
->bo
= src_buffer
->bo
;
672 src_image
->offset
= src_buffer
->offset
+ pRegions
[r
].srcOffset
;
673 dest_image
->bo
= dest_buffer
->bo
;
674 dest_image
->offset
= dest_buffer
->offset
+ pRegions
[r
].destOffset
;
676 VkImageViewCreateInfo src_view_info
= {
677 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
678 .image
= (VkImage
)src_image
,
679 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
680 .format
= VK_FORMAT_R8_UNORM
,
682 VK_CHANNEL_SWIZZLE_R
,
683 VK_CHANNEL_SWIZZLE_G
,
684 VK_CHANNEL_SWIZZLE_B
,
687 .subresourceRange
= {
688 .aspect
= VK_IMAGE_ASPECT_COLOR
,
697 VkImageView src_view
;
698 vkCreateImageView(vk_device
, &src_view_info
, &src_view
);
700 VkColorAttachmentViewCreateInfo dest_view_info
= {
701 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
702 .image
= (VkImage
)dest_image
,
703 .format
= VK_FORMAT_R8_UNORM
,
709 VkColorAttachmentView dest_view
;
710 vkCreateColorAttachmentView(vk_device
, &dest_view_info
, &dest_view
);
712 meta_emit_blit(cmd_buffer
,
713 (struct anv_surface_view
*)src_view
,
714 (VkOffset3D
) { 0, 0, 0 },
715 (VkExtent3D
) { pRegions
[r
].copySize
, 0, 0 },
716 (struct anv_surface_view
*)dest_view
,
717 (VkOffset3D
) { 0, 0, 0 },
718 (VkExtent3D
) { pRegions
[r
].copySize
, 0, 0 });
721 meta_finish_blit(cmd_buffer
, &saved_state
);
724 void anv_CmdCopyImage(
725 VkCmdBuffer cmdBuffer
,
727 VkImageLayout srcImageLayout
,
729 VkImageLayout destImageLayout
,
730 uint32_t regionCount
,
731 const VkImageCopy
* pRegions
)
733 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
734 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
735 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
736 struct anv_saved_state saved_state
;
738 meta_prepare_blit(cmd_buffer
, &saved_state
);
740 for (unsigned r
= 0; r
< regionCount
; r
++) {
741 VkImageViewCreateInfo src_view_info
= {
742 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
744 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
745 .format
= src_image
->format
,
747 VK_CHANNEL_SWIZZLE_R
,
748 VK_CHANNEL_SWIZZLE_G
,
749 VK_CHANNEL_SWIZZLE_B
,
752 .subresourceRange
= {
753 .aspect
= pRegions
[r
].srcSubresource
.aspect
,
754 .baseMipLevel
= pRegions
[r
].srcSubresource
.mipLevel
,
756 .baseArraySlice
= pRegions
[r
].srcSubresource
.arraySlice
,
762 VkImageView src_view
;
763 vkCreateImageView(vk_device
, &src_view_info
, &src_view
);
765 VkColorAttachmentViewCreateInfo dest_view_info
= {
766 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
768 .format
= src_image
->format
,
769 .mipLevel
= pRegions
[r
].destSubresource
.mipLevel
,
770 .baseArraySlice
= pRegions
[r
].destSubresource
.arraySlice
,
774 VkColorAttachmentView dest_view
;
775 vkCreateColorAttachmentView(vk_device
, &dest_view_info
, &dest_view
);
777 meta_emit_blit(cmd_buffer
,
778 (struct anv_surface_view
*)src_view
,
779 pRegions
[r
].srcOffset
,
781 (struct anv_surface_view
*)dest_view
,
782 pRegions
[r
].destOffset
,
786 meta_finish_blit(cmd_buffer
, &saved_state
);
789 void anv_CmdBlitImage(
790 VkCmdBuffer cmdBuffer
,
792 VkImageLayout srcImageLayout
,
794 VkImageLayout destImageLayout
,
795 uint32_t regionCount
,
796 const VkImageBlit
* pRegions
)
798 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
799 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
800 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
801 struct anv_image
*dest_image
= (struct anv_image
*)destImage
;
802 struct anv_saved_state saved_state
;
804 meta_prepare_blit(cmd_buffer
, &saved_state
);
806 for (unsigned r
= 0; r
< regionCount
; r
++) {
807 VkImageViewCreateInfo src_view_info
= {
808 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
810 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
811 .format
= src_image
->format
,
813 VK_CHANNEL_SWIZZLE_R
,
814 VK_CHANNEL_SWIZZLE_G
,
815 VK_CHANNEL_SWIZZLE_B
,
818 .subresourceRange
= {
819 .aspect
= pRegions
[r
].srcSubresource
.aspect
,
820 .baseMipLevel
= pRegions
[r
].srcSubresource
.mipLevel
,
822 .baseArraySlice
= pRegions
[r
].srcSubresource
.arraySlice
,
828 VkImageView src_view
;
829 vkCreateImageView(vk_device
, &src_view_info
, &src_view
);
831 VkColorAttachmentViewCreateInfo dest_view_info
= {
832 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
834 .format
= dest_image
->format
,
835 .mipLevel
= pRegions
[r
].destSubresource
.mipLevel
,
836 .baseArraySlice
= pRegions
[r
].destSubresource
.arraySlice
,
840 VkColorAttachmentView dest_view
;
841 vkCreateColorAttachmentView(vk_device
, &dest_view_info
, &dest_view
);
843 meta_emit_blit(cmd_buffer
,
844 (struct anv_surface_view
*)src_view
,
845 pRegions
[r
].srcOffset
,
846 pRegions
[r
].srcExtent
,
847 (struct anv_surface_view
*)dest_view
,
848 pRegions
[r
].destOffset
,
849 pRegions
[r
].destExtent
);
852 meta_finish_blit(cmd_buffer
, &saved_state
);
855 void anv_CmdCopyBufferToImage(
856 VkCmdBuffer cmdBuffer
,
859 VkImageLayout destImageLayout
,
860 uint32_t regionCount
,
861 const VkBufferImageCopy
* pRegions
)
863 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
864 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
865 struct anv_buffer
*src_buffer
= (struct anv_buffer
*)srcBuffer
;
866 struct anv_image
*dest_image
= (struct anv_image
*)destImage
;
867 struct anv_saved_state saved_state
;
869 meta_prepare_blit(cmd_buffer
, &saved_state
);
871 for (unsigned r
= 0; r
< regionCount
; r
++) {
872 VkImageCreateInfo src_image_info
= {
873 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
874 .imageType
= VK_IMAGE_TYPE_2D
,
875 .format
= dest_image
->format
,
877 .width
= pRegions
[r
].imageExtent
.width
,
878 .height
= pRegions
[r
].imageExtent
.height
,
884 .tiling
= VK_IMAGE_TILING_LINEAR
,
885 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
889 struct anv_image
*src_image
;
890 vkCreateImage(vk_device
, &src_image_info
, (VkImage
*)&src_image
);
892 /* We could use a vk call to bind memory, but that would require
893 * creating a dummy memory object etc. so there's really no point.
895 src_image
->bo
= src_buffer
->bo
;
896 src_image
->offset
= src_buffer
->offset
+ pRegions
[r
].bufferOffset
;
898 VkImageViewCreateInfo src_view_info
= {
899 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
900 .image
= (VkImage
)src_image
,
901 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
902 .format
= dest_image
->format
,
904 VK_CHANNEL_SWIZZLE_R
,
905 VK_CHANNEL_SWIZZLE_G
,
906 VK_CHANNEL_SWIZZLE_B
,
909 .subresourceRange
= {
910 .aspect
= pRegions
[r
].imageSubresource
.aspect
,
919 VkImageView src_view
;
920 vkCreateImageView(vk_device
, &src_view_info
, &src_view
);
922 VkColorAttachmentViewCreateInfo dest_view_info
= {
923 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
924 .image
= (VkImage
)dest_image
,
925 .format
= dest_image
->format
,
926 .mipLevel
= pRegions
[r
].imageSubresource
.mipLevel
,
927 .baseArraySlice
= pRegions
[r
].imageSubresource
.arraySlice
,
931 VkColorAttachmentView dest_view
;
932 vkCreateColorAttachmentView(vk_device
, &dest_view_info
, &dest_view
);
934 meta_emit_blit(cmd_buffer
,
935 (struct anv_surface_view
*)src_view
,
936 (VkOffset3D
) { 0, 0, 0 },
937 pRegions
[r
].imageExtent
,
938 (struct anv_surface_view
*)dest_view
,
939 pRegions
[r
].imageOffset
,
940 pRegions
[r
].imageExtent
);
943 meta_finish_blit(cmd_buffer
, &saved_state
);
946 void anv_CmdCopyImageToBuffer(
947 VkCmdBuffer cmdBuffer
,
949 VkImageLayout srcImageLayout
,
951 uint32_t regionCount
,
952 const VkBufferImageCopy
* pRegions
)
954 struct anv_cmd_buffer
*cmd_buffer
= (struct anv_cmd_buffer
*)cmdBuffer
;
955 VkDevice vk_device
= (VkDevice
) cmd_buffer
->device
;
956 struct anv_image
*src_image
= (struct anv_image
*)srcImage
;
957 struct anv_buffer
*dest_buffer
= (struct anv_buffer
*)destBuffer
;
958 struct anv_saved_state saved_state
;
960 meta_prepare_blit(cmd_buffer
, &saved_state
);
962 for (unsigned r
= 0; r
< regionCount
; r
++) {
963 VkImageViewCreateInfo src_view_info
= {
964 .sType
= VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO
,
966 .viewType
= VK_IMAGE_VIEW_TYPE_2D
,
967 .format
= src_image
->format
,
969 VK_CHANNEL_SWIZZLE_R
,
970 VK_CHANNEL_SWIZZLE_G
,
971 VK_CHANNEL_SWIZZLE_B
,
974 .subresourceRange
= {
975 .aspect
= pRegions
[r
].imageSubresource
.aspect
,
976 .baseMipLevel
= pRegions
[r
].imageSubresource
.mipLevel
,
978 .baseArraySlice
= pRegions
[r
].imageSubresource
.arraySlice
,
984 VkImageView src_view
;
985 anv_CreateImageView(vk_device
, &src_view_info
, &src_view
);
987 VkImageCreateInfo dest_image_info
= {
988 .sType
= VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
,
989 .imageType
= VK_IMAGE_TYPE_2D
,
990 .format
= src_image
->format
,
992 .width
= pRegions
[r
].imageExtent
.width
,
993 .height
= pRegions
[r
].imageExtent
.height
,
999 .tiling
= VK_IMAGE_TILING_LINEAR
,
1000 .usage
= VK_IMAGE_USAGE_SAMPLED_BIT
,
1004 struct anv_image
*dest_image
;
1005 anv_CreateImage(vk_device
, &dest_image_info
, (VkImage
*)&dest_image
);
1007 /* We could use a vk call to bind memory, but that would require
1008 * creating a dummy memory object etc. so there's really no point.
1010 dest_image
->bo
= dest_buffer
->bo
;
1011 dest_image
->offset
= dest_buffer
->offset
+ pRegions
[r
].bufferOffset
;
1013 VkColorAttachmentViewCreateInfo dest_view_info
= {
1014 .sType
= VK_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO
,
1015 .image
= (VkImage
)dest_image
,
1016 .format
= src_image
->format
,
1018 .baseArraySlice
= 0,
1022 VkColorAttachmentView dest_view
;
1023 anv_CreateColorAttachmentView(vk_device
, &dest_view_info
, &dest_view
);
1025 meta_emit_blit(cmd_buffer
,
1026 (struct anv_surface_view
*)src_view
,
1027 pRegions
[r
].imageOffset
,
1028 pRegions
[r
].imageExtent
,
1029 (struct anv_surface_view
*)dest_view
,
1030 (VkOffset3D
) { 0, 0, 0 },
1031 pRegions
[r
].imageExtent
);
1034 meta_finish_blit(cmd_buffer
, &saved_state
);
1037 void anv_CmdCloneImageData(
1038 VkCmdBuffer cmdBuffer
,
1040 VkImageLayout srcImageLayout
,
1042 VkImageLayout destImageLayout
)
1047 void anv_CmdUpdateBuffer(
1048 VkCmdBuffer cmdBuffer
,
1049 VkBuffer destBuffer
,
1050 VkDeviceSize destOffset
,
1051 VkDeviceSize dataSize
,
1052 const uint32_t* pData
)
1057 void anv_CmdFillBuffer(
1058 VkCmdBuffer cmdBuffer
,
1059 VkBuffer destBuffer
,
1060 VkDeviceSize destOffset
,
1061 VkDeviceSize fillSize
,
1067 void anv_CmdClearColorImage(
1068 VkCmdBuffer cmdBuffer
,
1070 VkImageLayout imageLayout
,
1071 const VkClearColor
* color
,
1072 uint32_t rangeCount
,
1073 const VkImageSubresourceRange
* pRanges
)
1078 void anv_CmdClearDepthStencil(
1079 VkCmdBuffer cmdBuffer
,
1081 VkImageLayout imageLayout
,
1084 uint32_t rangeCount
,
1085 const VkImageSubresourceRange
* pRanges
)
1090 void anv_CmdResolveImage(
1091 VkCmdBuffer cmdBuffer
,
1093 VkImageLayout srcImageLayout
,
1095 VkImageLayout destImageLayout
,
1096 uint32_t regionCount
,
1097 const VkImageResolve
* pRegions
)
1103 anv_device_init_meta(struct anv_device
*device
)
1105 anv_device_init_meta_clear_state(device
);
1106 anv_device_init_meta_blit_state(device
);