projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
radv: use the base object struct types
[mesa.git] / src / amd / vulkan / radv_pass.c
1 /*
2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
4 *
5 * based in part on anv driver which is:
6 * Copyright © 2015 Intel Corporation
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
14 *
15 * The above copyright notice and this permission notice (including the next
16 * paragraph) shall be included in all copies or substantial portions of the
17 * Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
24 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 * IN THE SOFTWARE.
26 */
27 #include "radv_private.h"
28
29 #include "vk_util.h"
30
31 static void
32 radv_render_pass_add_subpass_dep(struct radv_render_pass *pass,
33 const VkSubpassDependency2 *dep)
34 {
35 uint32_t src = dep->srcSubpass;
36 uint32_t dst = dep->dstSubpass;
37
38 /* Ignore subpass self-dependencies as they allow the app to call
39 * vkCmdPipelineBarrier() inside the render pass and the driver should
40 * only do the barrier when called, not when starting the render pass.
41 */
42 if (src == dst)
43 return;
44
45 /* Accumulate all ingoing external dependencies to the first subpass. */
46 if (src == VK_SUBPASS_EXTERNAL)
47 dst = 0;
48
49 if (dst == VK_SUBPASS_EXTERNAL) {
50 if (dep->dstStageMask != VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT)
51 pass->end_barrier.src_stage_mask |= dep->srcStageMask;
52 pass->end_barrier.src_access_mask |= dep->srcAccessMask;
53 pass->end_barrier.dst_access_mask |= dep->dstAccessMask;
54 } else {
55 if (dep->dstStageMask != VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT)
56 pass->subpasses[dst].start_barrier.src_stage_mask |= dep->srcStageMask;
57 pass->subpasses[dst].start_barrier.src_access_mask |= dep->srcAccessMask;
58 pass->subpasses[dst].start_barrier.dst_access_mask |= dep->dstAccessMask;
59 }
60 }
61
62 static bool
63 radv_pass_has_layout_transitions(const struct radv_render_pass *pass)
64 {
65 for (unsigned i = 0; i < pass->subpass_count; i++) {
66 const struct radv_subpass *subpass = &pass->subpasses[i];
67 for (unsigned j = 0; j < subpass->attachment_count; j++) {
68 const uint32_t a = subpass->attachments[j].attachment;
69 if (a == VK_ATTACHMENT_UNUSED)
70 continue;
71
72 uint32_t initial_layout = pass->attachments[a].initial_layout;
73 uint32_t stencil_initial_layout = pass->attachments[a].stencil_initial_layout;
74 uint32_t final_layout = pass->attachments[a].final_layout;
75 uint32_t stencil_final_layout = pass->attachments[a].stencil_final_layout;
76
77 if (subpass->attachments[j].layout != initial_layout ||
78 subpass->attachments[j].layout != stencil_initial_layout ||
79 subpass->attachments[j].layout != final_layout ||
80 subpass->attachments[j].layout != stencil_final_layout)
81 return true;
82 }
83 }
84
85 return false;
86 }
87
88 static void
89 radv_render_pass_add_implicit_deps(struct radv_render_pass *pass,
90 bool has_ingoing_dep, bool has_outgoing_dep)
91 {
92 /* From the Vulkan 1.0.39 spec:
93 *
94 * If there is no subpass dependency from VK_SUBPASS_EXTERNAL to the
95 * first subpass that uses an attachment, then an implicit subpass
96 * dependency exists from VK_SUBPASS_EXTERNAL to the first subpass it is
97 * used in. The implicit subpass dependency only exists if there
98 * exists an automatic layout transition away from initialLayout.
99 * The subpass dependency operates as if defined with the
100 * following parameters:
101 *
102 * VkSubpassDependency implicitDependency = {
103 * .srcSubpass = VK_SUBPASS_EXTERNAL;
104 * .dstSubpass = firstSubpass; // First subpass attachment is used in
105 * .srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
106 * .dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
107 * .srcAccessMask = 0;
108 * .dstAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
109 * VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
110 * VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
111 * VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
112 * VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
113 * .dependencyFlags = 0;
114 * };
115 *
116 * Similarly, if there is no subpass dependency from the last subpass
117 * that uses an attachment to VK_SUBPASS_EXTERNAL, then an implicit
118 * subpass dependency exists from the last subpass it is used in to
119 * VK_SUBPASS_EXTERNAL. The implicit subpass dependency only exists
120 * if there exists an automatic layout transition into finalLayout.
121 * The subpass dependency operates as if defined with the following
122 * parameters:
123 *
124 * VkSubpassDependency implicitDependency = {
125 * .srcSubpass = lastSubpass; // Last subpass attachment is used in
126 * .dstSubpass = VK_SUBPASS_EXTERNAL;
127 * .srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
128 * .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
129 * .srcAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
130 * VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
131 * VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
132 * VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
133 * VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
134 * .dstAccessMask = 0;
135 * .dependencyFlags = 0;
136 * };
137 */
138
139 /* Implicit subpass dependencies only make sense if automatic layout
140 * transitions are performed.
141 */
142 if (!radv_pass_has_layout_transitions(pass))
143 return;
144
145 if (!has_ingoing_dep) {
146 const VkSubpassDependency2KHR implicit_ingoing_dep = {
147 .srcSubpass = VK_SUBPASS_EXTERNAL,
148 .dstSubpass = 0,
149 .srcStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
150 .dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
151 .srcAccessMask = 0,
152 .dstAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
153 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
154 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
155 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
156 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
157 .dependencyFlags = 0,
158 };
159
160 radv_render_pass_add_subpass_dep(pass, &implicit_ingoing_dep);
161 }
162
163 if (!has_outgoing_dep) {
164 const VkSubpassDependency2KHR implicit_outgoing_dep = {
165 .srcSubpass = 0,
166 .dstSubpass = VK_SUBPASS_EXTERNAL,
167 .srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
168 .dstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
169 .srcAccessMask = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT |
170 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
171 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
172 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
173 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
174 .dstAccessMask = 0,
175 .dependencyFlags = 0,
176 };
177
178 radv_render_pass_add_subpass_dep(pass, &implicit_outgoing_dep);
179 }
180 }
181
182 static void
183 radv_render_pass_compile(struct radv_render_pass *pass)
184 {
185 for (uint32_t i = 0; i < pass->subpass_count; i++) {
186 struct radv_subpass *subpass = &pass->subpasses[i];
187
188 for (uint32_t j = 0; j < subpass->attachment_count; j++) {
189 struct radv_subpass_attachment *subpass_att =
190 &subpass->attachments[j];
191 if (subpass_att->attachment == VK_ATTACHMENT_UNUSED)
192 continue;
193
194 struct radv_render_pass_attachment *pass_att =
195 &pass->attachments[subpass_att->attachment];
196
197 pass_att->first_subpass_idx = UINT32_MAX;
198 }
199 }
200
201 for (uint32_t i = 0; i < pass->subpass_count; i++) {
202 struct radv_subpass *subpass = &pass->subpasses[i];
203 uint32_t color_sample_count = 1, depth_sample_count = 1;
204
205 /* We don't allow depth_stencil_attachment to be non-NULL and
206 * be VK_ATTACHMENT_UNUSED. This way something can just check
207 * for NULL and be guaranteed that they have a valid
208 * attachment.
209 */
210 if (subpass->depth_stencil_attachment &&
211 subpass->depth_stencil_attachment->attachment == VK_ATTACHMENT_UNUSED)
212 subpass->depth_stencil_attachment = NULL;
213
214 if (subpass->ds_resolve_attachment &&
215 subpass->ds_resolve_attachment->attachment == VK_ATTACHMENT_UNUSED)
216 subpass->ds_resolve_attachment = NULL;
217
218 for (uint32_t j = 0; j < subpass->attachment_count; j++) {
219 struct radv_subpass_attachment *subpass_att =
220 &subpass->attachments[j];
221 if (subpass_att->attachment == VK_ATTACHMENT_UNUSED)
222 continue;
223
224 struct radv_render_pass_attachment *pass_att =
225 &pass->attachments[subpass_att->attachment];
226
227 if (i < pass_att->first_subpass_idx)
228 pass_att->first_subpass_idx = i;
229 pass_att->last_subpass_idx = i;
230 }
231
232 subpass->has_color_att = false;
233 for (uint32_t j = 0; j < subpass->color_count; j++) {
234 struct radv_subpass_attachment *subpass_att =
235 &subpass->color_attachments[j];
236 if (subpass_att->attachment == VK_ATTACHMENT_UNUSED)
237 continue;
238
239 subpass->has_color_att = true;
240
241 struct radv_render_pass_attachment *pass_att =
242 &pass->attachments[subpass_att->attachment];
243
244 color_sample_count = pass_att->samples;
245 }
246
247 if (subpass->depth_stencil_attachment) {
248 const uint32_t a =
249 subpass->depth_stencil_attachment->attachment;
250 struct radv_render_pass_attachment *pass_att =
251 &pass->attachments[a];
252 depth_sample_count = pass_att->samples;
253 }
254
255 subpass->max_sample_count = MAX2(color_sample_count,
256 depth_sample_count);
257 subpass->color_sample_count = color_sample_count;
258 subpass->depth_sample_count = depth_sample_count;
259
260 /* We have to handle resolve attachments specially */
261 subpass->has_color_resolve = false;
262 if (subpass->resolve_attachments) {
263 for (uint32_t j = 0; j < subpass->color_count; j++) {
264 struct radv_subpass_attachment *resolve_att =
265 &subpass->resolve_attachments[j];
266
267 if (resolve_att->attachment == VK_ATTACHMENT_UNUSED)
268 continue;
269
270 subpass->has_color_resolve = true;
271 }
272 }
273
274 for (uint32_t j = 0; j < subpass->input_count; ++j) {
275 if (subpass->input_attachments[j].attachment == VK_ATTACHMENT_UNUSED)
276 continue;
277
278 for (uint32_t k = 0; k < subpass->color_count; ++k) {
279 if (subpass->color_attachments[k].attachment == subpass->input_attachments[j].attachment) {
280 subpass->input_attachments[j].in_render_loop = true;
281 subpass->color_attachments[k].in_render_loop = true;
282 }
283 }
284
285 if (subpass->depth_stencil_attachment &&
286 subpass->depth_stencil_attachment->attachment == subpass->input_attachments[j].attachment) {
287 subpass->input_attachments[j].in_render_loop = true;
288 subpass->depth_stencil_attachment->in_render_loop = true;
289 }
290 }
291 }
292 }
293
294 static unsigned
295 radv_num_subpass_attachments(const VkSubpassDescription *desc)
296 {
297 return desc->inputAttachmentCount +
298 desc->colorAttachmentCount +
299 (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
300 (desc->pDepthStencilAttachment != NULL);
301 }
302
303 VkResult radv_CreateRenderPass(
304 VkDevice _device,
305 const VkRenderPassCreateInfo* pCreateInfo,
306 const VkAllocationCallbacks* pAllocator,
307 VkRenderPass* pRenderPass)
308 {
309 RADV_FROM_HANDLE(radv_device, device, _device);
310 struct radv_render_pass *pass;
311 size_t size;
312 size_t attachments_offset;
313 VkRenderPassMultiviewCreateInfo *multiview_info = NULL;
314
315 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO);
316
317 size = sizeof(*pass);
318 size += pCreateInfo->subpassCount * sizeof(pass->subpasses[0]);
319 attachments_offset = size;
320 size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]);
321
322 pass = vk_alloc2(&device->vk.alloc, pAllocator, size, 8,
323 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
324 if (pass == NULL)
325 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
326
327 memset(pass, 0, size);
328
329 vk_object_base_init(&device->vk, &pass->base,
330 VK_OBJECT_TYPE_RENDER_PASS);
331
332 pass->attachment_count = pCreateInfo->attachmentCount;
333 pass->subpass_count = pCreateInfo->subpassCount;
334 pass->attachments = (void *) pass + attachments_offset;
335
336 vk_foreach_struct(ext, pCreateInfo->pNext) {
337 switch(ext->sType) {
338 case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
339 multiview_info = (VkRenderPassMultiviewCreateInfo*)ext;
340 break;
341 default:
342 break;
343 }
344 }
345
346 for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) {
347 struct radv_render_pass_attachment *att = &pass->attachments[i];
348
349 att->format = pCreateInfo->pAttachments[i].format;
350 att->samples = pCreateInfo->pAttachments[i].samples;
351 att->load_op = pCreateInfo->pAttachments[i].loadOp;
352 att->stencil_load_op = pCreateInfo->pAttachments[i].stencilLoadOp;
353 att->initial_layout = pCreateInfo->pAttachments[i].initialLayout;
354 att->final_layout = pCreateInfo->pAttachments[i].finalLayout;
355 att->stencil_initial_layout = pCreateInfo->pAttachments[i].initialLayout;
356 att->stencil_final_layout = pCreateInfo->pAttachments[i].finalLayout;
357 // att->store_op = pCreateInfo->pAttachments[i].storeOp;
358 // att->stencil_store_op = pCreateInfo->pAttachments[i].stencilStoreOp;
359 }
360 uint32_t subpass_attachment_count = 0;
361 struct radv_subpass_attachment *p;
362 for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
363 subpass_attachment_count +=
364 radv_num_subpass_attachments(&pCreateInfo->pSubpasses[i]);
365 }
366
367 if (subpass_attachment_count) {
368 pass->subpass_attachments =
369 vk_alloc2(&device->vk.alloc, pAllocator,
370 subpass_attachment_count * sizeof(struct radv_subpass_attachment), 8,
371 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
372 if (pass->subpass_attachments == NULL) {
373 vk_free2(&device->vk.alloc, pAllocator, pass);
374 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
375 }
376 } else
377 pass->subpass_attachments = NULL;
378
379 p = pass->subpass_attachments;
380 for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
381 const VkSubpassDescription *desc = &pCreateInfo->pSubpasses[i];
382 struct radv_subpass *subpass = &pass->subpasses[i];
383
384 subpass->input_count = desc->inputAttachmentCount;
385 subpass->color_count = desc->colorAttachmentCount;
386 subpass->attachment_count = radv_num_subpass_attachments(desc);
387 subpass->attachments = p;
388
389 if (multiview_info)
390 subpass->view_mask = multiview_info->pViewMasks[i];
391
392 if (desc->inputAttachmentCount > 0) {
393 subpass->input_attachments = p;
394 p += desc->inputAttachmentCount;
395
396 for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) {
397 subpass->input_attachments[j] = (struct radv_subpass_attachment) {
398 .attachment = desc->pInputAttachments[j].attachment,
399 .layout = desc->pInputAttachments[j].layout,
400 .stencil_layout = desc->pInputAttachments[j].layout,
401 };
402 }
403 }
404
405 if (desc->colorAttachmentCount > 0) {
406 subpass->color_attachments = p;
407 p += desc->colorAttachmentCount;
408
409 for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
410 subpass->color_attachments[j] = (struct radv_subpass_attachment) {
411 .attachment = desc->pColorAttachments[j].attachment,
412 .layout = desc->pColorAttachments[j].layout,
413 };
414 }
415 }
416
417 if (desc->pResolveAttachments) {
418 subpass->resolve_attachments = p;
419 p += desc->colorAttachmentCount;
420
421 for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
422 subpass->resolve_attachments[j] = (struct radv_subpass_attachment) {
423 .attachment = desc->pResolveAttachments[j].attachment,
424 .layout = desc->pResolveAttachments[j].layout,
425 .stencil_layout = desc->pResolveAttachments[j].layout,
426 };
427 }
428 }
429
430 if (desc->pDepthStencilAttachment) {
431 subpass->depth_stencil_attachment = p++;
432
433 *subpass->depth_stencil_attachment = (struct radv_subpass_attachment) {
434 .attachment = desc->pDepthStencilAttachment->attachment,
435 .layout = desc->pDepthStencilAttachment->layout,
436 .stencil_layout = desc->pDepthStencilAttachment->layout,
437 };
438 }
439 }
440
441 bool has_ingoing_dep = false;
442 bool has_outgoing_dep = false;
443
444 for (unsigned i = 0; i < pCreateInfo->dependencyCount; ++i) {
445 /* Convert to a Dependency2 */
446 struct VkSubpassDependency2 dep2 = {
447 .srcSubpass = pCreateInfo->pDependencies[i].srcSubpass,
448 .dstSubpass = pCreateInfo->pDependencies[i].dstSubpass,
449 .srcStageMask = pCreateInfo->pDependencies[i].srcStageMask,
450 .dstStageMask = pCreateInfo->pDependencies[i].dstStageMask,
451 .srcAccessMask = pCreateInfo->pDependencies[i].srcAccessMask,
452 .dstAccessMask = pCreateInfo->pDependencies[i].dstAccessMask,
453 .dependencyFlags = pCreateInfo->pDependencies[i].dependencyFlags,
454 };
455 radv_render_pass_add_subpass_dep(pass, &dep2);
456
457 /* Determine if the subpass has explicit dependencies from/to
458 * VK_SUBPASS_EXTERNAL.
459 */
460 if (pCreateInfo->pDependencies[i].srcSubpass == VK_SUBPASS_EXTERNAL)
461 has_ingoing_dep = true;
462 if (pCreateInfo->pDependencies[i].dstSubpass == VK_SUBPASS_EXTERNAL)
463 has_outgoing_dep = true;
464 }
465
466 radv_render_pass_add_implicit_deps(pass,
467 has_ingoing_dep, has_outgoing_dep);
468
469 radv_render_pass_compile(pass);
470
471 *pRenderPass = radv_render_pass_to_handle(pass);
472
473 return VK_SUCCESS;
474 }
475
476 static unsigned
477 radv_num_subpass_attachments2(const VkSubpassDescription2 *desc)
478 {
479 const VkSubpassDescriptionDepthStencilResolve *ds_resolve =
480 vk_find_struct_const(desc->pNext,
481 SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
482
483 return desc->inputAttachmentCount +
484 desc->colorAttachmentCount +
485 (desc->pResolveAttachments ? desc->colorAttachmentCount : 0) +
486 (desc->pDepthStencilAttachment != NULL) +
487 (ds_resolve && ds_resolve->pDepthStencilResolveAttachment);
488 }
489
490 VkResult radv_CreateRenderPass2(
491 VkDevice _device,
492 const VkRenderPassCreateInfo2* pCreateInfo,
493 const VkAllocationCallbacks* pAllocator,
494 VkRenderPass* pRenderPass)
495 {
496 RADV_FROM_HANDLE(radv_device, device, _device);
497 struct radv_render_pass *pass;
498 size_t size;
499 size_t attachments_offset;
500
501 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2);
502
503 size = sizeof(*pass);
504 size += pCreateInfo->subpassCount * sizeof(pass->subpasses[0]);
505 attachments_offset = size;
506 size += pCreateInfo->attachmentCount * sizeof(pass->attachments[0]);
507
508 pass = vk_alloc2(&device->vk.alloc, pAllocator, size, 8,
509 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
510 if (pass == NULL)
511 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
512
513 memset(pass, 0, size);
514
515 vk_object_base_init(&device->vk, &pass->base,
516 VK_OBJECT_TYPE_RENDER_PASS);
517
518 pass->attachment_count = pCreateInfo->attachmentCount;
519 pass->subpass_count = pCreateInfo->subpassCount;
520 pass->attachments = (void *) pass + attachments_offset;
521
522 for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) {
523 struct radv_render_pass_attachment *att = &pass->attachments[i];
524 const VkAttachmentDescriptionStencilLayoutKHR *stencil_layout =
525 vk_find_struct_const(pCreateInfo->pAttachments[i].pNext,
526 ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR);
527
528 att->format = pCreateInfo->pAttachments[i].format;
529 att->samples = pCreateInfo->pAttachments[i].samples;
530 att->load_op = pCreateInfo->pAttachments[i].loadOp;
531 att->stencil_load_op = pCreateInfo->pAttachments[i].stencilLoadOp;
532 att->initial_layout = pCreateInfo->pAttachments[i].initialLayout;
533 att->final_layout = pCreateInfo->pAttachments[i].finalLayout;
534 att->stencil_initial_layout = (stencil_layout ?
535 stencil_layout->stencilInitialLayout :
536 pCreateInfo->pAttachments[i].initialLayout);
537 att->stencil_final_layout = (stencil_layout ?
538 stencil_layout->stencilFinalLayout :
539 pCreateInfo->pAttachments[i].finalLayout);
540 // att->store_op = pCreateInfo->pAttachments[i].storeOp;
541 // att->stencil_store_op = pCreateInfo->pAttachments[i].stencilStoreOp;
542 }
543 uint32_t subpass_attachment_count = 0;
544 struct radv_subpass_attachment *p;
545 for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
546 subpass_attachment_count +=
547 radv_num_subpass_attachments2(&pCreateInfo->pSubpasses[i]);
548 }
549
550 if (subpass_attachment_count) {
551 pass->subpass_attachments =
552 vk_alloc2(&device->vk.alloc, pAllocator,
553 subpass_attachment_count * sizeof(struct radv_subpass_attachment), 8,
554 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
555 if (pass->subpass_attachments == NULL) {
556 vk_free2(&device->vk.alloc, pAllocator, pass);
557 return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
558 }
559 } else
560 pass->subpass_attachments = NULL;
561
562 p = pass->subpass_attachments;
563 for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) {
564 const VkSubpassDescription2 *desc = &pCreateInfo->pSubpasses[i];
565 struct radv_subpass *subpass = &pass->subpasses[i];
566
567 subpass->input_count = desc->inputAttachmentCount;
568 subpass->color_count = desc->colorAttachmentCount;
569 subpass->attachment_count = radv_num_subpass_attachments2(desc);
570 subpass->attachments = p;
571 subpass->view_mask = desc->viewMask;
572
573 if (desc->inputAttachmentCount > 0) {
574 subpass->input_attachments = p;
575 p += desc->inputAttachmentCount;
576
577 for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) {
578 const VkAttachmentReferenceStencilLayoutKHR *stencil_attachment =
579 vk_find_struct_const(desc->pInputAttachments[j].pNext,
580 ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR);
581
582 subpass->input_attachments[j] = (struct radv_subpass_attachment) {
583 .attachment = desc->pInputAttachments[j].attachment,
584 .layout = desc->pInputAttachments[j].layout,
585 .stencil_layout = (stencil_attachment ?
586 stencil_attachment->stencilLayout :
587 desc->pInputAttachments[j].layout),
588 };
589 }
590 }
591
592 if (desc->colorAttachmentCount > 0) {
593 subpass->color_attachments = p;
594 p += desc->colorAttachmentCount;
595
596 for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
597 subpass->color_attachments[j] = (struct radv_subpass_attachment) {
598 .attachment = desc->pColorAttachments[j].attachment,
599 .layout = desc->pColorAttachments[j].layout,
600 };
601 }
602 }
603
604 if (desc->pResolveAttachments) {
605 subpass->resolve_attachments = p;
606 p += desc->colorAttachmentCount;
607
608 for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) {
609 subpass->resolve_attachments[j] = (struct radv_subpass_attachment) {
610 .attachment = desc->pResolveAttachments[j].attachment,
611 .layout = desc->pResolveAttachments[j].layout,
612 };
613 }
614 }
615
616 if (desc->pDepthStencilAttachment) {
617 subpass->depth_stencil_attachment = p++;
618
619 const VkAttachmentReferenceStencilLayoutKHR *stencil_attachment =
620 vk_find_struct_const(desc->pDepthStencilAttachment->pNext,
621 ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR);
622
623 *subpass->depth_stencil_attachment = (struct radv_subpass_attachment) {
624 .attachment = desc->pDepthStencilAttachment->attachment,
625 .layout = desc->pDepthStencilAttachment->layout,
626 .stencil_layout = (stencil_attachment ?
627 stencil_attachment->stencilLayout :
628 desc->pDepthStencilAttachment->layout),
629 };
630 }
631
632 const VkSubpassDescriptionDepthStencilResolve *ds_resolve =
633 vk_find_struct_const(desc->pNext,
634 SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE);
635
636 if (ds_resolve && ds_resolve->pDepthStencilResolveAttachment) {
637 subpass->ds_resolve_attachment = p++;
638
639 const VkAttachmentReferenceStencilLayoutKHR *stencil_resolve_attachment =
640 vk_find_struct_const(ds_resolve->pDepthStencilResolveAttachment->pNext,
641 ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR);
642
643 *subpass->ds_resolve_attachment = (struct radv_subpass_attachment) {
644 .attachment = ds_resolve->pDepthStencilResolveAttachment->attachment,
645 .layout = ds_resolve->pDepthStencilResolveAttachment->layout,
646 .stencil_layout = (stencil_resolve_attachment ?
647 stencil_resolve_attachment->stencilLayout :
648 ds_resolve->pDepthStencilResolveAttachment->layout),
649 };
650
651 subpass->depth_resolve_mode = ds_resolve->depthResolveMode;
652 subpass->stencil_resolve_mode = ds_resolve->stencilResolveMode;
653 }
654 }
655
656 bool has_ingoing_dep = false;
657 bool has_outgoing_dep = false;
658
659 for (unsigned i = 0; i < pCreateInfo->dependencyCount; ++i) {
660 radv_render_pass_add_subpass_dep(pass,
661 &pCreateInfo->pDependencies[i]);
662
663 /* Determine if the subpass has explicit dependencies from/to
664 * VK_SUBPASS_EXTERNAL.
665 */
666 if (pCreateInfo->pDependencies[i].srcSubpass == VK_SUBPASS_EXTERNAL)
667 has_ingoing_dep = true;
668 if (pCreateInfo->pDependencies[i].dstSubpass == VK_SUBPASS_EXTERNAL)
669 has_outgoing_dep = true;
670 }
671
672 radv_render_pass_add_implicit_deps(pass,
673 has_ingoing_dep, has_outgoing_dep);
674
675 radv_render_pass_compile(pass);
676
677 *pRenderPass = radv_render_pass_to_handle(pass);
678
679 return VK_SUCCESS;
680 }
681
682 void radv_DestroyRenderPass(
683 VkDevice _device,
684 VkRenderPass _pass,
685 const VkAllocationCallbacks* pAllocator)
686 {
687 RADV_FROM_HANDLE(radv_device, device, _device);
688 RADV_FROM_HANDLE(radv_render_pass, pass, _pass);
689
690 if (!_pass)
691 return;
692
693 vk_object_base_finish(&pass->base);
694 vk_free2(&device->vk.alloc, pAllocator, pass->subpass_attachments);
695 vk_free2(&device->vk.alloc, pAllocator, pass);
696 }
697
698 void radv_GetRenderAreaGranularity(
699 VkDevice device,
700 VkRenderPass renderPass,
701 VkExtent2D* pGranularity)
702 {
703 pGranularity->width = 1;
704 pGranularity->height = 1;
705 }
706