1 /*
2 * Copyright 2018 Collabora Ltd.
3 *
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 * on the rights to use, copy, modify, merge, publish, distribute, sub
8 * license, and/or sell copies of the Software, and to permit persons to whom
9 * the Software is furnished to do so, subject to the following conditions:
10 *
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
13 * Software.
14 *
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 NON-INFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
21 * USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "zink_context.h"
25 #include "zink_clear.h"
26 #include "zink_framebuffer.h"
27 #include "zink_kopper.h"
28 #include "zink_query.h"
29 #include "zink_render_pass.h"
30 #include "zink_resource.h"
31 #include "zink_screen.h"
32 #include "zink_surface.h"
33
34 #include "util/u_memory.h"
35 #include "util/u_string.h"
36 #include "util/u_blitter.h"
37
38 static VkAttachmentLoadOp
get_rt_loadop(const struct zink_rt_attrib * rt,bool clear)39 get_rt_loadop(const struct zink_rt_attrib *rt, bool clear)
40 {
41 return clear ? VK_ATTACHMENT_LOAD_OP_CLEAR :
42 /* TODO: need replicate EXT */
43 //rt->resolve || rt->invalid ?
44 rt->invalid ?
45 VK_ATTACHMENT_LOAD_OP_DONT_CARE :
46 VK_ATTACHMENT_LOAD_OP_LOAD;
47 }
48
49 static VkImageLayout
get_color_rt_layout(const struct zink_rt_attrib * rt)50 get_color_rt_layout(const struct zink_rt_attrib *rt)
51 {
52 return rt->feedback_loop ? VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT : rt->fbfetch ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
53 }
54
55 static VkImageLayout
get_zs_rt_layout(const struct zink_rt_attrib * rt)56 get_zs_rt_layout(const struct zink_rt_attrib *rt)
57 {
58 bool has_clear = rt->clear_color || rt->clear_stencil;
59 if (rt->feedback_loop)
60 return VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT;
61 return rt->needs_write || has_clear ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
62 }
63
64 static VkRenderPass
create_render_pass2(struct zink_screen * screen,struct zink_render_pass_state * state,struct zink_render_pass_pipeline_state * pstate)65 create_render_pass2(struct zink_screen *screen, struct zink_render_pass_state *state, struct zink_render_pass_pipeline_state *pstate)
66 {
67
68 VkAttachmentReference2 color_refs[PIPE_MAX_COLOR_BUFS], color_resolves[PIPE_MAX_COLOR_BUFS], zs_ref, zs_resolve;
69 VkAttachmentReference2 input_attachments[PIPE_MAX_COLOR_BUFS];
70 VkAttachmentDescription2 attachments[2 * (PIPE_MAX_COLOR_BUFS + 1)];
71 VkPipelineStageFlags dep_pipeline = 0;
72 VkAccessFlags dep_access = 0;
73 unsigned input_count = 0;
74 const unsigned cresolve_offset = state->num_cbufs + state->have_zsbuf;
75 const unsigned zsresolve_offset = cresolve_offset + state->num_cresolves;
76
77 pstate->num_attachments = state->num_cbufs;
78 pstate->num_cresolves = state->num_cresolves;
79 pstate->num_zsresolves = state->num_zsresolves;
80 pstate->fbfetch = 0;
81 pstate->msaa_samples = state->msaa_samples;
82 for (int i = 0; i < state->num_cbufs; i++) {
83 struct zink_rt_attrib *rt = state->rts + i;
84 attachments[i].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
85 attachments[i].pNext = NULL;
86 attachments[i].flags = 0;
87 pstate->attachments[i].format = attachments[i].format = rt->format;
88 pstate->attachments[i].samples = attachments[i].samples = rt->samples;
89 attachments[i].loadOp = get_rt_loadop(rt, rt->clear_color);
90
91 /* TODO: need replicate EXT */
92 //attachments[i].storeOp = rt->resolve ? VK_ATTACHMENT_STORE_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE;
93 attachments[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
94 attachments[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
95 attachments[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
96 /* if layout changes are ever handled here, need VkAttachmentSampleLocationsEXT */
97 VkImageLayout layout = get_color_rt_layout(rt);
98 attachments[i].initialLayout = layout;
99 attachments[i].finalLayout = layout;
100 color_refs[i].sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
101 color_refs[i].pNext = NULL;
102 color_refs[i].attachment = i;
103 color_refs[i].layout = layout;
104 color_refs[i].aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
105 dep_pipeline |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
106 if (rt->fbfetch) {
107 memcpy(&input_attachments[input_count++], &color_refs[i], sizeof(VkAttachmentReference2));
108 dep_pipeline |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
109 dep_access |= VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
110 pstate->fbfetch = 1;
111 }
112 dep_access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
113 if (attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
114 dep_access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
115
116 if (rt->resolve) {
117 memcpy(&attachments[cresolve_offset + i], &attachments[i], sizeof(VkAttachmentDescription2));
118 attachments[cresolve_offset + i].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
119 attachments[cresolve_offset + i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
120 attachments[cresolve_offset + i].samples = 1;
121 memcpy(&color_resolves[i], &color_refs[i], sizeof(VkAttachmentReference2));
122 color_resolves[i].attachment = cresolve_offset + i;
123 if (attachments[cresolve_offset + i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
124 dep_access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
125 }
126 }
127
128 int num_attachments = state->num_cbufs;
129 if (state->have_zsbuf) {
130 struct zink_rt_attrib *rt = state->rts + state->num_cbufs;
131 VkImageLayout layout = get_zs_rt_layout(rt);
132 attachments[num_attachments].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
133 attachments[num_attachments].pNext = NULL;
134 attachments[num_attachments].flags = 0;
135 pstate->attachments[num_attachments].format = attachments[num_attachments].format = rt->format;
136 pstate->attachments[num_attachments].samples = attachments[num_attachments].samples = rt->samples;
137 attachments[num_attachments].loadOp = get_rt_loadop(rt, rt->clear_color);
138 attachments[num_attachments].stencilLoadOp = get_rt_loadop(rt, rt->clear_stencil);
139 /* TODO: need replicate EXT */
140 //attachments[num_attachments].storeOp = rt->resolve ? VK_ATTACHMENT_LOAD_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE;
141 //attachments[num_attachments].stencilStoreOp = rt->resolve ? VK_ATTACHMENT_LOAD_OP_DONT_CARE : VK_ATTACHMENT_STORE_OP_STORE;
142 attachments[num_attachments].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
143 attachments[num_attachments].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
144 /* if layout changes are ever handled here, need VkAttachmentSampleLocationsEXT */
145 attachments[num_attachments].initialLayout = layout;
146 attachments[num_attachments].finalLayout = layout;
147
148 dep_pipeline |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
149 if (layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
150 dep_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
151 if (attachments[num_attachments].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD ||
152 attachments[num_attachments].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
153 dep_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
154
155 zs_ref.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
156 zs_ref.pNext = NULL;
157 zs_ref.attachment = num_attachments;
158 zs_ref.layout = layout;
159 if (rt->resolve) {
160 memcpy(&attachments[zsresolve_offset], &attachments[num_attachments], sizeof(VkAttachmentDescription2));
161 attachments[zsresolve_offset].loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
162 attachments[zsresolve_offset].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
163 attachments[zsresolve_offset].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
164 attachments[zsresolve_offset].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
165 attachments[zsresolve_offset].samples = 1;
166 memcpy(&zs_resolve, &zs_ref, sizeof(VkAttachmentReference2));
167 zs_resolve.attachment = zsresolve_offset;
168 if (attachments[zsresolve_offset].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD ||
169 attachments[zsresolve_offset].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
170 dep_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
171 }
172 num_attachments++;
173 pstate->num_attachments++;
174 }
175 pstate->color_read = (dep_access & VK_ACCESS_COLOR_ATTACHMENT_READ_BIT) > 0;
176 pstate->depth_read = (dep_access & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT) > 0;
177 pstate->depth_write = (dep_access & VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT) > 0;
178
179 if (!screen->info.have_KHR_synchronization2)
180 dep_pipeline = MAX2(dep_pipeline, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
181
182 VkDependencyFlags flag = screen->info.have_KHR_synchronization2 ? VK_DEPENDENCY_BY_REGION_BIT : 0;
183 VkSubpassDependency2 deps[] = {
184 {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, flag, 0},
185 {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, flag, 0}
186 };
187 VkPipelineStageFlags input_dep = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
188 //if (zs_fbfetch) input_dep |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
189 VkAccessFlags input_access = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
190 //if (zs_fbfetch) input_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
191 VkSubpassDependency2 fbfetch_deps[] = {
192 {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, flag, 0},
193 {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, 0, dep_pipeline, input_dep, dep_access, input_access, flag, 0},
194 {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, flag, 0}
195 };
196
197 VkSubpassDescription2 subpass = {0};
198 if (pstate->fbfetch && screen->info.have_EXT_rasterization_order_attachment_access)
199 subpass.flags |= VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT;
200 VkSubpassDescriptionDepthStencilResolve zsresolve;
201 subpass.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
202 subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
203 subpass.colorAttachmentCount = state->num_cbufs;
204 subpass.pColorAttachments = color_refs;
205 subpass.pDepthStencilAttachment = state->have_zsbuf ? &zs_ref : NULL;
206 subpass.inputAttachmentCount = input_count;
207 subpass.pInputAttachments = input_attachments;
208 if (state->num_cresolves)
209 subpass.pResolveAttachments = color_resolves;
210 if (state->num_zsresolves) {
211 subpass.pNext = &zsresolve;
212 zsresolve.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
213 zsresolve.pNext = NULL;
214 zsresolve.depthResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
215 zsresolve.stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
216 zsresolve.pDepthStencilResolveAttachment = &zs_resolve;
217 } else
218 subpass.pNext = NULL;
219
220 VkMultisampledRenderToSingleSampledInfoEXT msrtss = {
221 VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
222 &subpass.pNext,
223 VK_TRUE,
224 state->msaa_samples,
225 };
226 if (state->msaa_samples)
227 subpass.pNext = &msrtss;
228
229 VkRenderPassCreateInfo2 rpci = {0};
230 rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
231 rpci.attachmentCount = num_attachments + state->num_cresolves + state->num_zsresolves;
232 rpci.pAttachments = attachments;
233 rpci.subpassCount = 1;
234 rpci.pSubpasses = &subpass;
235 rpci.dependencyCount = input_count ? 3 : 2;
236 rpci.pDependencies = input_count ? fbfetch_deps : deps;
237
238 VkRenderPass render_pass;
239 VkResult result = VKSCR(CreateRenderPass2)(screen->dev, &rpci, NULL, &render_pass);
240 if (result != VK_SUCCESS) {
241 mesa_loge("ZINK: vkCreateRenderPass2 failed (%s)", vk_Result_to_str(result));
242 return VK_NULL_HANDLE;
243 }
244
245 return render_pass;
246 }
247
248 struct zink_render_pass *
zink_create_render_pass(struct zink_screen * screen,struct zink_render_pass_state * state,struct zink_render_pass_pipeline_state * pstate)249 zink_create_render_pass(struct zink_screen *screen,
250 struct zink_render_pass_state *state,
251 struct zink_render_pass_pipeline_state *pstate)
252 {
253 struct zink_render_pass *rp = CALLOC_STRUCT(zink_render_pass);
254 if (!rp)
255 goto fail;
256
257 rp->render_pass = create_render_pass2(screen, state, pstate);
258 if (!rp->render_pass)
259 goto fail;
260 memcpy(&rp->state, state, sizeof(struct zink_render_pass_state));
261 return rp;
262
263 fail:
264 if (rp)
265 zink_destroy_render_pass(screen, rp);
266 return NULL;
267 }
268
269 void
zink_destroy_render_pass(struct zink_screen * screen,struct zink_render_pass * rp)270 zink_destroy_render_pass(struct zink_screen *screen,
271 struct zink_render_pass *rp)
272 {
273 VKSCR(DestroyRenderPass)(screen->dev, rp->render_pass, NULL);
274 FREE(rp);
275 }
276
277 VkImageLayout
zink_render_pass_attachment_get_barrier_info(const struct zink_rt_attrib * rt,bool color,VkPipelineStageFlags * pipeline,VkAccessFlags * access)278 zink_render_pass_attachment_get_barrier_info(const struct zink_rt_attrib *rt, bool color,
279 VkPipelineStageFlags *pipeline, VkAccessFlags *access)
280 {
281 *access = 0;
282 if (color) {
283 *pipeline = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
284 *access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
285 if (!rt->clear_color && !rt->invalid)
286 *access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
287 return get_color_rt_layout(rt);
288 }
289
290 *pipeline = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
291 if (!rt->clear_color && !rt->clear_stencil)
292 *access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
293 if (rt->clear_color || rt->clear_stencil || rt->needs_write)
294 *access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
295 return get_zs_rt_layout(rt);
296 }
297
298 VkImageLayout
zink_tc_renderpass_info_parse(struct zink_context * ctx,const struct tc_renderpass_info * info,unsigned idx,VkPipelineStageFlags * pipeline,VkAccessFlags * access)299 zink_tc_renderpass_info_parse(struct zink_context *ctx, const struct tc_renderpass_info *info, unsigned idx, VkPipelineStageFlags *pipeline, VkAccessFlags *access)
300 {
301 if (idx < PIPE_MAX_COLOR_BUFS) {
302 *pipeline = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
303 *access = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
304 if (info->cbuf_load & BITFIELD_BIT(idx))
305 *access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
306 return (ctx->feedback_loops & BITFIELD_BIT(idx)) ? VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT :
307 (info->cbuf_fbfetch & BITFIELD_BIT(idx)) ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
308 } else {
309 *access = 0;
310 if (info->zsbuf_load || info->zsbuf_read_dsa)
311 *access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
312 if (info->zsbuf_clear | info->zsbuf_clear_partial | info->zsbuf_write_fs | info->zsbuf_write_dsa)
313 *access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
314 assert(*access);
315 *pipeline = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
316 if (ctx->feedback_loops & BITFIELD_BIT(PIPE_MAX_COLOR_BUFS))
317 return VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT;
318 return (info->zsbuf_clear | info->zsbuf_clear_partial | info->zsbuf_write_fs | info->zsbuf_write_dsa) ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
319 }
320 }
321
322 static size_t
rp_state_size(const struct zink_render_pass_pipeline_state * pstate)323 rp_state_size(const struct zink_render_pass_pipeline_state *pstate)
324 {
325 return offsetof(struct zink_render_pass_pipeline_state, attachments) +
326 sizeof(pstate->attachments[0]) * pstate->num_attachments;
327 }
328
329 static uint32_t
hash_rp_state(const void * key)330 hash_rp_state(const void *key)
331 {
332 const struct zink_render_pass_pipeline_state *s = key;
333 return _mesa_hash_data(key, rp_state_size(s));
334 }
335
336 static bool
equals_rp_state(const void * a,const void * b)337 equals_rp_state(const void *a, const void *b)
338 {
339 return !memcmp(a, b, rp_state_size(a));
340 }
341
342 static uint32_t
hash_render_pass_state(const void * key)343 hash_render_pass_state(const void *key)
344 {
345 struct zink_render_pass_state* s = (struct zink_render_pass_state*)key;
346 return _mesa_hash_data(key, offsetof(struct zink_render_pass_state, rts) + sizeof(s->rts[0]) * s->num_rts);
347 }
348
349 static bool
equals_render_pass_state(const void * a,const void * b)350 equals_render_pass_state(const void *a, const void *b)
351 {
352 const struct zink_render_pass_state *s_a = a, *s_b = b;
353 if (s_a->num_rts != s_b->num_rts)
354 return false;
355 return memcmp(a, b, offsetof(struct zink_render_pass_state, rts) + sizeof(s_a->rts[0]) * s_a->num_rts) == 0;
356 }
357
358 void
zink_init_zs_attachment(struct zink_context * ctx,struct zink_rt_attrib * rt)359 zink_init_zs_attachment(struct zink_context *ctx, struct zink_rt_attrib *rt)
360 {
361 const struct pipe_framebuffer_state *fb = &ctx->fb_state;
362 struct zink_resource *zsbuf = zink_resource(fb->zsbuf->texture);
363 struct zink_framebuffer_clear *fb_clear = &ctx->fb_clears[PIPE_MAX_COLOR_BUFS];
364 struct zink_surface *transient = zink_transient_surface(fb->zsbuf);
365 rt->format = zsbuf->format;
366 rt->samples = MAX3(transient ? transient->base.nr_samples : 0, fb->zsbuf->texture->nr_samples, 1);
367 rt->clear_color = zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) &&
368 !zink_fb_clear_first_needs_explicit(fb_clear) &&
369 (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_DEPTH);
370 rt->clear_stencil = zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) &&
371 !zink_fb_clear_first_needs_explicit(fb_clear) &&
372 (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_STENCIL);
373 const uint64_t outputs_written = ctx->gfx_stages[MESA_SHADER_FRAGMENT] ?
374 ctx->gfx_stages[MESA_SHADER_FRAGMENT]->info.outputs_written : 0;
375 bool needs_write_z = (ctx->dsa_state && ctx->dsa_state->hw_state.depth_write) ||
376 outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH);
377 needs_write_z |= transient || rt->clear_color ||
378 (zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) && (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_DEPTH));
379
380 bool needs_write_s = (ctx->dsa_state && (util_writes_stencil(&ctx->dsa_state->base.stencil[0]) || util_writes_stencil(&ctx->dsa_state->base.stencil[1]))) ||
381 rt->clear_stencil || (outputs_written & BITFIELD64_BIT(FRAG_RESULT_STENCIL)) ||
382 (zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) && (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_STENCIL));
383 rt->needs_write = needs_write_z | needs_write_s;
384 rt->invalid = !zsbuf->valid;
385 rt->feedback_loop = (ctx->feedback_loops & BITFIELD_BIT(PIPE_MAX_COLOR_BUFS)) > 0;
386 }
387
388 void
zink_tc_init_zs_attachment(struct zink_context * ctx,const struct tc_renderpass_info * info,struct zink_rt_attrib * rt)389 zink_tc_init_zs_attachment(struct zink_context *ctx, const struct tc_renderpass_info *info, struct zink_rt_attrib *rt)
390 {
391 const struct pipe_framebuffer_state *fb = &ctx->fb_state;
392 struct zink_resource *zsbuf = zink_resource(fb->zsbuf->texture);
393 struct zink_framebuffer_clear *fb_clear = &ctx->fb_clears[PIPE_MAX_COLOR_BUFS];
394 struct zink_surface *transient = zink_transient_surface(fb->zsbuf);
395 rt->format = zsbuf->format;
396 rt->samples = MAX3(transient ? transient->base.nr_samples : 0, fb->zsbuf->texture->nr_samples, 1);
397 rt->clear_color = zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) &&
398 !zink_fb_clear_first_needs_explicit(fb_clear) &&
399 (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_DEPTH);
400 rt->clear_stencil = zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS) &&
401 !zink_fb_clear_first_needs_explicit(fb_clear) &&
402 (zink_fb_clear_element(fb_clear, 0)->zs.bits & PIPE_CLEAR_STENCIL);
403 rt->needs_write = info->zsbuf_clear | info->zsbuf_clear_partial | info->zsbuf_write_fs | info->zsbuf_write_dsa;
404 rt->invalid = !zsbuf->valid;
405 rt->feedback_loop = (ctx->feedback_loops & BITFIELD_BIT(PIPE_MAX_COLOR_BUFS)) > 0;
406 }
407
408 void
zink_init_color_attachment(struct zink_context * ctx,unsigned i,struct zink_rt_attrib * rt)409 zink_init_color_attachment(struct zink_context *ctx, unsigned i, struct zink_rt_attrib *rt)
410 {
411 const struct pipe_framebuffer_state *fb = &ctx->fb_state;
412 struct pipe_surface *psurf = fb->cbufs[i];
413 if (psurf) {
414 struct zink_surface *surf = zink_csurface(psurf);
415 struct zink_surface *transient = zink_transient_surface(psurf);
416 rt->format = surf->info.format[0];
417 rt->samples = MAX3(transient ? transient->base.nr_samples : 0, psurf->texture->nr_samples, 1);
418 rt->clear_color = zink_fb_clear_enabled(ctx, i) && !zink_fb_clear_first_needs_explicit(&ctx->fb_clears[i]);
419 rt->invalid = !zink_resource(psurf->texture)->valid;
420 rt->fbfetch = (ctx->fbfetch_outputs & BITFIELD_BIT(i)) > 0;
421 rt->feedback_loop = (ctx->feedback_loops & BITFIELD_BIT(i)) > 0;
422 } else {
423 memset(rt, 0, sizeof(struct zink_rt_attrib));
424 rt->format = VK_FORMAT_R8G8B8A8_UNORM;
425 rt->samples = fb->samples;
426 }
427 }
428
429 void
zink_tc_init_color_attachment(struct zink_context * ctx,const struct tc_renderpass_info * info,unsigned i,struct zink_rt_attrib * rt)430 zink_tc_init_color_attachment(struct zink_context *ctx, const struct tc_renderpass_info *info, unsigned i, struct zink_rt_attrib *rt)
431 {
432 const struct pipe_framebuffer_state *fb = &ctx->fb_state;
433 struct pipe_surface *psurf = fb->cbufs[i];
434 if (psurf) {
435 struct zink_surface *surf = zink_csurface(psurf);
436 struct zink_surface *transient = zink_transient_surface(psurf);
437 rt->format = surf->info.format[0];
438 rt->samples = MAX3(transient ? transient->base.nr_samples : 0, psurf->texture->nr_samples, 1);
439 rt->clear_color = zink_fb_clear_enabled(ctx, i) && !zink_fb_clear_first_needs_explicit(&ctx->fb_clears[i]);
440 rt->invalid = !zink_resource(psurf->texture)->valid;
441 rt->fbfetch = (info->cbuf_fbfetch & BITFIELD_BIT(i)) > 0;
442 rt->feedback_loop = (ctx->feedback_loops & BITFIELD_BIT(i)) > 0;
443 } else {
444 memset(rt, 0, sizeof(struct zink_rt_attrib));
445 rt->format = VK_FORMAT_R8G8B8A8_UNORM;
446 rt->samples = fb->samples;
447 }
448 }
449
450 static struct zink_render_pass *
get_render_pass(struct zink_context * ctx)451 get_render_pass(struct zink_context *ctx)
452 {
453 struct zink_screen *screen = zink_screen(ctx->base.screen);
454 const struct pipe_framebuffer_state *fb = &ctx->fb_state;
455 struct zink_render_pass_state state = {0};
456 uint32_t clears = 0;
457 bool have_zsbuf = fb->zsbuf && zink_is_zsbuf_used(ctx);
458 bool use_tc_info = !ctx->blitting && ctx->track_renderpasses;
459 state.samples = fb->samples > 0;
460
461 for (int i = 0; i < fb->nr_cbufs; i++) {
462 if (use_tc_info)
463 zink_tc_init_color_attachment(ctx, &ctx->dynamic_fb.tc_info, i, &state.rts[i]);
464 else
465 zink_init_color_attachment(ctx, i, &state.rts[i]);
466 struct pipe_surface *surf = fb->cbufs[i];
467 if (surf) {
468 clears |= !!state.rts[i].clear_color ? PIPE_CLEAR_COLOR0 << i : 0;
469 struct zink_surface *transient = zink_transient_surface(surf);
470 if (transient) {
471 state.num_cresolves++;
472 state.rts[i].resolve = true;
473 if (!state.rts[i].clear_color)
474 state.msaa_expand_mask |= BITFIELD_BIT(i);
475 } else {
476 state.rts[i].resolve = false;
477 }
478 }
479 state.num_rts++;
480 }
481 state.msaa_samples = screen->info.have_EXT_multisampled_render_to_single_sampled && ctx->transient_attachments ?
482 ctx->gfx_pipeline_state.rast_samples + 1 : 0;
483 state.num_cbufs = fb->nr_cbufs;
484 assert(!state.num_cresolves || state.num_cbufs == state.num_cresolves);
485
486 if (have_zsbuf) {
487 if (use_tc_info)
488 zink_tc_init_zs_attachment(ctx, &ctx->dynamic_fb.tc_info, &state.rts[fb->nr_cbufs]);
489 else
490 zink_init_zs_attachment(ctx, &state.rts[fb->nr_cbufs]);
491 struct zink_surface *transient = zink_transient_surface(fb->zsbuf);
492 if (transient) {
493 state.num_zsresolves = 1;
494 state.rts[fb->nr_cbufs].resolve = true;
495 }
496 if (state.rts[fb->nr_cbufs].clear_color)
497 clears |= PIPE_CLEAR_DEPTH;
498 if (state.rts[fb->nr_cbufs].clear_stencil)
499 clears |= PIPE_CLEAR_STENCIL;
500 state.num_rts++;
501 }
502 state.have_zsbuf = have_zsbuf;
503 assert(clears == ctx->rp_clears_enabled);
504 state.clears = clears;
505 uint32_t hash = hash_render_pass_state(&state);
506 struct hash_entry *entry = _mesa_hash_table_search_pre_hashed(ctx->render_pass_cache, hash,
507 &state);
508 struct zink_render_pass *rp;
509 if (entry) {
510 rp = entry->data;
511 assert(rp->state.clears == clears);
512 } else {
513 struct zink_render_pass_pipeline_state pstate;
514 pstate.samples = state.samples;
515 rp = zink_create_render_pass(screen, &state, &pstate);
516 if (!_mesa_hash_table_insert_pre_hashed(ctx->render_pass_cache, hash, &rp->state, rp))
517 return NULL;
518 bool found = false;
519 struct set_entry *cache_entry = _mesa_set_search_or_add(&ctx->render_pass_state_cache, &pstate, &found);
520 struct zink_render_pass_pipeline_state *ppstate;
521 if (!found) {
522 cache_entry->key = ralloc(ctx, struct zink_render_pass_pipeline_state);
523 ppstate = (void*)cache_entry->key;
524 memcpy(ppstate, &pstate, rp_state_size(&pstate));
525 ppstate->id = ctx->render_pass_state_cache.entries;
526 }
527 ppstate = (void*)cache_entry->key;
528 rp->pipeline_state = ppstate->id;
529 }
530 return rp;
531 }
532
533 /* check whether the active rp needs to be split to replace it with rp2 */
534 static bool
rp_must_change(const struct zink_render_pass * rp,const struct zink_render_pass * rp2,bool in_rp)535 rp_must_change(const struct zink_render_pass *rp, const struct zink_render_pass *rp2, bool in_rp)
536 {
537 if (rp == rp2)
538 return false;
539 unsigned num_cbufs = rp->state.num_cbufs;
540 if (rp->pipeline_state != rp2->pipeline_state) {
541 /* if any core attrib bits are different, must split */
542 if (rp->state.val != rp2->state.val)
543 return true;
544 for (unsigned i = 0; i < num_cbufs; i++) {
545 const struct zink_rt_attrib *rt = &rp->state.rts[i];
546 const struct zink_rt_attrib *rt2 = &rp2->state.rts[i];
547 /* if layout changed, must split */
548 if (get_color_rt_layout(rt) != get_color_rt_layout(rt2))
549 return true;
550 }
551 }
552 if (rp->state.have_zsbuf) {
553 const struct zink_rt_attrib *rt = &rp->state.rts[num_cbufs];
554 const struct zink_rt_attrib *rt2 = &rp2->state.rts[num_cbufs];
555 /* if zs layout has gone from read-only to read-write, split renderpass */
556 if (get_zs_rt_layout(rt) == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL &&
557 get_zs_rt_layout(rt2) == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
558 return true;
559 }
560 /* any other change doesn't require splitting a renderpass */
561 return !in_rp;
562 }
563
564 static void
setup_framebuffer(struct zink_context * ctx)565 setup_framebuffer(struct zink_context *ctx)
566 {
567 struct zink_screen *screen = zink_screen(ctx->base.screen);
568 struct zink_render_pass *rp = ctx->gfx_pipeline_state.render_pass;
569
570 zink_update_vk_sample_locations(ctx);
571
572 if (ctx->rp_changed || ctx->rp_layout_changed || (!ctx->in_rp && ctx->rp_loadop_changed)) {
573 /* 0. ensure no stale pointers are set */
574 ctx->gfx_pipeline_state.next_render_pass = NULL;
575 /* 1. calc new rp */
576 rp = get_render_pass(ctx);
577 /* 2. evaluate whether to use new rp */
578 if (ctx->gfx_pipeline_state.render_pass) {
579 /* 2a. if previous rp exists, check whether new rp MUST be used */
580 bool must_change = rp_must_change(ctx->gfx_pipeline_state.render_pass, rp, ctx->in_rp);
581 ctx->fb_changed |= must_change;
582 if (!must_change)
583 /* 2b. if non-essential attribs have changed, store for later use and continue on */
584 ctx->gfx_pipeline_state.next_render_pass = rp;
585 } else {
586 /* 2c. no previous rp in use, use this one */
587 ctx->fb_changed = true;
588 }
589 } else if (ctx->gfx_pipeline_state.next_render_pass) {
590 /* previous rp was calculated but deferred: use it */
591 assert(!ctx->in_rp);
592 rp = ctx->gfx_pipeline_state.next_render_pass;
593 ctx->gfx_pipeline_state.next_render_pass = NULL;
594 ctx->fb_changed = true;
595 }
596 if (rp->pipeline_state != ctx->gfx_pipeline_state.rp_state) {
597 ctx->gfx_pipeline_state.rp_state = rp->pipeline_state;
598 ctx->gfx_pipeline_state.dirty = true;
599 }
600
601 ctx->rp_loadop_changed = false;
602 ctx->rp_layout_changed = false;
603 ctx->rp_changed = false;
604
605 if (zink_render_update_swapchain(ctx))
606 zink_render_fixup_swapchain(ctx);
607
608 if (!ctx->fb_changed)
609 return;
610
611 zink_update_framebuffer_state(ctx);
612 zink_init_framebuffer(screen, ctx->framebuffer, rp);
613 ctx->fb_changed = false;
614 ctx->gfx_pipeline_state.render_pass = rp;
615 zink_batch_no_rp(ctx);
616 }
617
618 static bool
prep_fb_attachments(struct zink_context * ctx,VkImageView * att)619 prep_fb_attachments(struct zink_context *ctx, VkImageView *att)
620 {
621 bool have_zsbuf = ctx->fb_state.zsbuf && zink_is_zsbuf_used(ctx);
622 const unsigned cresolve_offset = ctx->fb_state.nr_cbufs + !!have_zsbuf;
623 unsigned num_resolves = 0;
624 for (int i = 0; i < ctx->fb_state.nr_cbufs; i++) {
625 struct zink_surface *surf = zink_csurface(ctx->fb_state.cbufs[i]);
626 struct zink_surface *transient = zink_transient_surface(ctx->fb_state.cbufs[i]);
627 if (transient) {
628 att[i] = zink_prep_fb_attachment(ctx, transient, i);
629 att[i + cresolve_offset] = zink_prep_fb_attachment(ctx, surf, i);
630 num_resolves++;
631 } else {
632 att[i] = zink_prep_fb_attachment(ctx, surf, i);
633 if (!att[i])
634 /* dead swapchain */
635 return false;
636 }
637 }
638 if (have_zsbuf) {
639 struct zink_surface *surf = zink_csurface(ctx->fb_state.zsbuf);
640 struct zink_surface *transient = zink_transient_surface(ctx->fb_state.zsbuf);
641 if (transient) {
642 att[ctx->fb_state.nr_cbufs] = zink_prep_fb_attachment(ctx, transient, ctx->fb_state.nr_cbufs);
643 att[cresolve_offset + num_resolves] = zink_prep_fb_attachment(ctx, surf, ctx->fb_state.nr_cbufs);
644 } else {
645 att[ctx->fb_state.nr_cbufs] = zink_prep_fb_attachment(ctx, surf, ctx->fb_state.nr_cbufs);
646 }
647 }
648 return true;
649 }
650
651 static unsigned
begin_render_pass(struct zink_context * ctx)652 begin_render_pass(struct zink_context *ctx)
653 {
654 struct pipe_framebuffer_state *fb_state = &ctx->fb_state;
655
656 VkRenderPassBeginInfo rpbi = {0};
657 rpbi.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
658 rpbi.renderPass = ctx->gfx_pipeline_state.render_pass->render_pass;
659 rpbi.renderArea.offset.x = 0;
660 rpbi.renderArea.offset.y = 0;
661 rpbi.renderArea.extent.width = fb_state->width;
662 rpbi.renderArea.extent.height = fb_state->height;
663
664 if (ctx->fb_state.cbufs[0]) {
665 struct zink_resource *res = zink_resource(ctx->fb_state.cbufs[0]->texture);
666 if (zink_is_swapchain(res)) {
667 if (res->use_damage)
668 rpbi.renderArea = res->damage;
669 }
670 }
671
672 VkClearValue clears[PIPE_MAX_COLOR_BUFS + 1] = {0};
673 unsigned clear_buffers = 0;
674 uint32_t clear_validate = 0;
675 for (int i = 0; i < fb_state->nr_cbufs; i++) {
676 /* these are no-ops */
677 if (!fb_state->cbufs[i] || !zink_fb_clear_enabled(ctx, i))
678 continue;
679 /* these need actual clear calls inside the rp */
680 struct zink_framebuffer_clear_data *clear = zink_fb_clear_element(&ctx->fb_clears[i], 0);
681 if (zink_fb_clear_needs_explicit(&ctx->fb_clears[i])) {
682 clear_buffers |= (PIPE_CLEAR_COLOR0 << i);
683 if (zink_fb_clear_count(&ctx->fb_clears[i]) < 2 ||
684 zink_fb_clear_element_needs_explicit(clear))
685 continue;
686 }
687 /* we now know there's one clear that can be done here */
688 memcpy(&clears[i].color, &clear->color, sizeof(float) * 4);
689 rpbi.clearValueCount = i + 1;
690 clear_validate |= PIPE_CLEAR_COLOR0 << i;
691 assert(ctx->framebuffer->rp->state.clears);
692 }
693 if (fb_state->zsbuf && zink_fb_clear_enabled(ctx, PIPE_MAX_COLOR_BUFS)) {
694 struct zink_framebuffer_clear *fb_clear = &ctx->fb_clears[PIPE_MAX_COLOR_BUFS];
695 struct zink_framebuffer_clear_data *clear = zink_fb_clear_element(fb_clear, 0);
696 if (!zink_fb_clear_element_needs_explicit(clear)) {
697 clears[fb_state->nr_cbufs].depthStencil.depth = clear->zs.depth;
698 clears[fb_state->nr_cbufs].depthStencil.stencil = clear->zs.stencil;
699 rpbi.clearValueCount = fb_state->nr_cbufs + 1;
700 clear_validate |= clear->zs.bits;
701 assert(ctx->framebuffer->rp->state.clears);
702 }
703 if (zink_fb_clear_needs_explicit(fb_clear)) {
704 for (int j = !zink_fb_clear_element_needs_explicit(clear);
705 (clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL && j < zink_fb_clear_count(fb_clear);
706 j++)
707 clear_buffers |= zink_fb_clear_element(fb_clear, j)->zs.bits;
708 }
709 }
710 assert(clear_validate == ctx->framebuffer->rp->state.clears);
711 rpbi.pClearValues = &clears[0];
712 rpbi.framebuffer = ctx->framebuffer->fb;
713
714 assert(ctx->gfx_pipeline_state.render_pass && ctx->framebuffer);
715
716 VkRenderPassAttachmentBeginInfo infos;
717 VkImageView att[2 * (PIPE_MAX_COLOR_BUFS + 1)];
718 infos.sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
719 infos.pNext = NULL;
720 infos.attachmentCount = ctx->framebuffer->state.num_attachments;
721 infos.pAttachments = att;
722 if (!prep_fb_attachments(ctx, att))
723 return 0;
724 ctx->zsbuf_unused = !zink_is_zsbuf_used(ctx);
725 /* this can be set if fbfetch is activated */
726 ctx->rp_changed = false;
727 #ifndef NDEBUG
728 bool zsbuf_used = ctx->fb_state.zsbuf && zink_is_zsbuf_used(ctx);
729 const unsigned cresolve_offset = ctx->fb_state.nr_cbufs + !!zsbuf_used;
730 unsigned num_cresolves = 0;
731 for (int i = 0; i < ctx->fb_state.nr_cbufs; i++) {
732 if (ctx->fb_state.cbufs[i]) {
733 struct zink_surface *surf = zink_csurface(ctx->fb_state.cbufs[i]);
734 struct zink_surface *transient = zink_transient_surface(ctx->fb_state.cbufs[i]);
735 if (surf->base.format == ctx->fb_state.cbufs[i]->format) {
736 if (transient) {
737 num_cresolves++;
738 assert(zink_resource(transient->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[i].usage);
739 assert(zink_resource(surf->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[cresolve_offset].usage);
740 } else {
741 assert(zink_resource(surf->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[i].usage);
742 }
743 }
744 }
745 }
746 if (ctx->gfx_pipeline_state.render_pass->state.have_zsbuf) {
747 struct zink_surface *surf = zink_csurface(ctx->fb_state.zsbuf);
748 struct zink_surface *transient = zink_transient_surface(ctx->fb_state.zsbuf);
749 if (transient) {
750 assert(zink_resource(transient->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[ctx->fb_state.nr_cbufs].usage);
751 assert(zink_resource(surf->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[cresolve_offset + num_cresolves].usage);
752 } else {
753 assert(zink_resource(surf->base.texture)->obj->vkusage == ctx->framebuffer->state.infos[ctx->fb_state.nr_cbufs].usage);
754 }
755 }
756 #endif
757 rpbi.pNext = &infos;
758
759 VKCTX(CmdBeginRenderPass)(ctx->bs->cmdbuf, &rpbi, VK_SUBPASS_CONTENTS_INLINE);
760 ctx->in_rp = true;
761 return clear_buffers;
762 }
763
764 void
zink_render_msaa_expand(struct zink_context * ctx,uint32_t msaa_expand_mask)765 zink_render_msaa_expand(struct zink_context *ctx, uint32_t msaa_expand_mask)
766 {
767 assert(msaa_expand_mask);
768
769 bool blitting = ctx->blitting;
770 u_foreach_bit(i, msaa_expand_mask) {
771 struct zink_ctx_surface *csurf = (struct zink_ctx_surface*)ctx->fb_state.cbufs[i];
772 /* skip replicate blit if the image will be full-cleared */
773 if ((i == PIPE_MAX_COLOR_BUFS && (ctx->rp_clears_enabled & PIPE_CLEAR_DEPTHSTENCIL)) ||
774 (ctx->rp_clears_enabled >> 2) & BITFIELD_BIT(i)) {
775 csurf->transient_init |= zink_fb_clear_full_exists(ctx, i);
776 }
777 if (csurf->transient_init)
778 continue;
779 struct pipe_surface *dst_view = (struct pipe_surface*)csurf->transient;
780 assert(dst_view);
781 struct pipe_sampler_view src_templ, *src_view;
782 struct pipe_resource *src = ctx->fb_state.cbufs[i]->texture;
783 struct pipe_box dstbox;
784
785 u_box_3d(0, 0, 0, ctx->fb_state.width, ctx->fb_state.height,
786 1 + dst_view->u.tex.last_layer - dst_view->u.tex.first_layer, &dstbox);
787
788 util_blitter_default_src_texture(ctx->blitter, &src_templ, src, ctx->fb_state.cbufs[i]->u.tex.level);
789 src_view = ctx->base.create_sampler_view(&ctx->base, src, &src_templ);
790
791 zink_blit_begin(ctx, ZINK_BLIT_SAVE_FB | ZINK_BLIT_SAVE_FS | ZINK_BLIT_SAVE_TEXTURES);
792 ctx->blitting = false;
793 zink_blit_barriers(ctx, zink_resource(src), zink_resource(dst_view->texture), true);
794 ctx->blitting = true;
795 unsigned clear_mask = i == PIPE_MAX_COLOR_BUFS ?
796 (BITFIELD_MASK(PIPE_MAX_COLOR_BUFS) << 2) :
797 (PIPE_CLEAR_DEPTHSTENCIL | ((BITFIELD_MASK(PIPE_MAX_COLOR_BUFS) & ~BITFIELD_BIT(i)) << 2));
798 unsigned clears_enabled = ctx->clears_enabled & clear_mask;
799 unsigned rp_clears_enabled = ctx->rp_clears_enabled & clear_mask;
800 ctx->clears_enabled &= ~clear_mask;
801 ctx->rp_clears_enabled &= ~clear_mask;
802 util_blitter_blit_generic(ctx->blitter, dst_view, &dstbox,
803 src_view, &dstbox, ctx->fb_state.width, ctx->fb_state.height,
804 PIPE_MASK_RGBAZS, PIPE_TEX_FILTER_NEAREST, NULL,
805 false, false, 0, NULL);
806 ctx->clears_enabled = clears_enabled;
807 ctx->rp_clears_enabled = rp_clears_enabled;
808 ctx->blitting = false;
809 if (blitting) {
810 zink_blit_barriers(ctx, NULL, zink_resource(dst_view->texture), true);
811 zink_blit_barriers(ctx, NULL, zink_resource(src), true);
812 }
813 ctx->blitting = blitting;
814 pipe_sampler_view_reference(&src_view, NULL);
815 csurf->transient_init = true;
816 }
817 }
818
819 unsigned
zink_begin_render_pass(struct zink_context * ctx)820 zink_begin_render_pass(struct zink_context *ctx)
821 {
822 setup_framebuffer(ctx);
823 if (ctx->in_rp)
824 return 0;
825
826 if (ctx->framebuffer->rp->state.msaa_expand_mask) {
827 uint32_t rp_state = ctx->gfx_pipeline_state.rp_state;
828 struct zink_render_pass *rp = ctx->gfx_pipeline_state.render_pass;
829 struct zink_framebuffer *fb = ctx->framebuffer;
830
831 zink_render_msaa_expand(ctx, ctx->framebuffer->rp->state.msaa_expand_mask);
832 ctx->rp_layout_changed = ctx->rp_loadop_changed = false;
833 ctx->fb_changed = ctx->rp_changed = false;
834 ctx->gfx_pipeline_state.rp_state = rp_state;
835 ctx->gfx_pipeline_state.render_pass = rp;
836 /* manually re-set fb: depth buffer may have been eliminated */
837 ctx->framebuffer = fb;
838 ctx->framebuffer->rp = rp;
839 }
840 assert(ctx->gfx_pipeline_state.render_pass);
841 return begin_render_pass(ctx);
842 }
843
844 void
zink_end_render_pass(struct zink_context * ctx)845 zink_end_render_pass(struct zink_context *ctx)
846 {
847 if (ctx->in_rp) {
848 VKCTX(CmdEndRenderPass)(ctx->bs->cmdbuf);
849
850 for (unsigned i = 0; i < ctx->fb_state.nr_cbufs; i++) {
851 struct zink_ctx_surface *csurf = (struct zink_ctx_surface*)ctx->fb_state.cbufs[i];
852 if (csurf)
853 csurf->transient_init = true;
854 }
855 }
856 ctx->in_rp = false;
857 }
858
859 bool
zink_init_render_pass(struct zink_context * ctx)860 zink_init_render_pass(struct zink_context *ctx)
861 {
862 _mesa_set_init(&ctx->render_pass_state_cache, ctx, hash_rp_state, equals_rp_state);
863 ctx->render_pass_cache = _mesa_hash_table_create(NULL,
864 hash_render_pass_state,
865 equals_render_pass_state);
866 return !!ctx->render_pass_cache;
867 }
868
869 void
zink_render_fixup_swapchain(struct zink_context * ctx)870 zink_render_fixup_swapchain(struct zink_context *ctx)
871 {
872 if ((ctx->swapchain_size.width || ctx->swapchain_size.height)) {
873 unsigned old_w = ctx->fb_state.width;
874 unsigned old_h = ctx->fb_state.height;
875 ctx->fb_state.width = ctx->swapchain_size.width;
876 ctx->fb_state.height = ctx->swapchain_size.height;
877 ctx->dynamic_fb.info.renderArea.extent.width = MIN2(ctx->dynamic_fb.info.renderArea.extent.width, ctx->fb_state.width);
878 ctx->dynamic_fb.info.renderArea.extent.height = MIN2(ctx->dynamic_fb.info.renderArea.extent.height, ctx->fb_state.height);
879 zink_kopper_fixup_depth_buffer(ctx);
880 if (ctx->fb_state.width != old_w || ctx->fb_state.height != old_h)
881 ctx->scissor_changed = true;
882 if (ctx->framebuffer)
883 zink_update_framebuffer_state(ctx);
884 ctx->swapchain_size.width = ctx->swapchain_size.height = 0;
885 }
886 }
887
888 bool
zink_render_update_swapchain(struct zink_context * ctx)889 zink_render_update_swapchain(struct zink_context *ctx)
890 {
891 bool has_swapchain = false;
892 for (unsigned i = 0; i < ctx->fb_state.nr_cbufs; i++) {
893 if (!ctx->fb_state.cbufs[i])
894 continue;
895 struct zink_resource *res = zink_resource(ctx->fb_state.cbufs[i]->texture);
896 if (zink_is_swapchain(res)) {
897 has_swapchain = true;
898 if (zink_kopper_acquire(ctx, res, UINT64_MAX))
899 zink_surface_swapchain_update(ctx, zink_csurface(ctx->fb_state.cbufs[i]));
900 }
901 }
902 return has_swapchain;
903 }
904