2 * Copyright © 2017 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 shall be included
12 * in all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 * DEALINGS IN THE SOFTWARE.
25 #include "pipe/p_defines.h"
26 #include "pipe/p_state.h"
27 #include "pipe/p_context.h"
28 #include "pipe/p_screen.h"
29 #include "util/u_inlines.h"
30 #include "util/u_format.h"
31 #include "util/u_upload_mgr.h"
32 #include "util/ralloc.h"
33 #include "iris_context.h"
34 #include "iris_resource.h"
35 #include "iris_screen.h"
36 #include "intel/compiler/brw_compiler.h"
39 clear_color(struct iris_context
*ice
,
40 struct pipe_resource
*p_res
,
42 const struct pipe_box
*box
,
43 bool render_condition_enabled
,
44 enum isl_format format
,
45 union isl_color_value color
)
47 struct iris_resource
*res
= (void *) p_res
;
49 struct iris_batch
*batch
= &ice
->batches
[IRIS_BATCH_RENDER
];
50 const struct gen_device_info
*devinfo
= &batch
->screen
->devinfo
;
51 enum blorp_batch_flags blorp_flags
= 0;
53 if (render_condition_enabled
) {
54 if (ice
->state
.predicate
== IRIS_PREDICATE_STATE_DONT_RENDER
)
57 if (ice
->state
.predicate
== IRIS_PREDICATE_STATE_USE_BIT
)
58 blorp_flags
|= BLORP_BATCH_PREDICATE_ENABLE
;
61 iris_batch_maybe_flush(batch
, 1500);
63 struct blorp_batch blorp_batch
;
64 blorp_batch_init(&ice
->blorp
, &blorp_batch
, batch
, blorp_flags
);
66 bool color_write_disable
[4] = { false, false, false, false };
67 enum isl_aux_usage aux_usage
=
68 iris_resource_render_aux_usage(ice
, res
, format
,
71 iris_resource_prepare_render(ice
, batch
, res
, level
,
72 box
->z
, box
->depth
, aux_usage
);
74 struct blorp_surf surf
;
75 iris_blorp_surf_for_resource(&ice
->vtbl
, &surf
, p_res
, aux_usage
, level
,
78 if (!isl_format_supports_rendering(devinfo
, format
) &&
79 isl_format_is_rgbx(format
))
80 format
= isl_format_rgbx_to_rgba(format
);
82 blorp_clear(&blorp_batch
, &surf
, format
, ISL_SWIZZLE_IDENTITY
,
83 level
, box
->z
, box
->depth
, box
->x
, box
->y
,
84 box
->x
+ box
->width
, box
->y
+ box
->height
,
85 color
, color_write_disable
);
87 blorp_batch_finish(&blorp_batch
);
88 iris_flush_and_dirty_for_history(ice
, batch
, res
);
90 iris_resource_finish_render(ice
, res
, level
,
91 box
->z
, box
->depth
, aux_usage
);
96 clear_depth_stencil(struct iris_context
*ice
,
97 struct pipe_resource
*p_res
,
99 const struct pipe_box
*box
,
100 bool render_condition_enabled
,
106 struct iris_resource
*res
= (void *) p_res
;
108 struct iris_batch
*batch
= &ice
->batches
[IRIS_BATCH_RENDER
];
109 enum blorp_batch_flags blorp_flags
= 0;
111 if (render_condition_enabled
) {
112 if (ice
->state
.predicate
== IRIS_PREDICATE_STATE_DONT_RENDER
)
115 if (ice
->state
.predicate
== IRIS_PREDICATE_STATE_USE_BIT
)
116 blorp_flags
|= BLORP_BATCH_PREDICATE_ENABLE
;
119 iris_batch_maybe_flush(batch
, 1500);
121 struct blorp_batch blorp_batch
;
122 blorp_batch_init(&ice
->blorp
, &blorp_batch
, batch
, blorp_flags
);
124 struct iris_resource
*z_res
;
125 struct iris_resource
*stencil_res
;
126 struct blorp_surf z_surf
;
127 struct blorp_surf stencil_surf
;
129 iris_get_depth_stencil_resources(p_res
, &z_res
, &stencil_res
);
132 iris_resource_prepare_depth(ice
, batch
, z_res
, level
, box
->z
, box
->depth
);
133 iris_blorp_surf_for_resource(&ice
->vtbl
, &z_surf
, &z_res
->base
,
134 z_res
->aux
.usage
, level
, true);
138 iris_blorp_surf_for_resource(&ice
->vtbl
, &stencil_surf
,
139 &stencil_res
->base
, stencil_res
->aux
.usage
,
143 blorp_clear_depth_stencil(&blorp_batch
, &z_surf
, &stencil_surf
,
144 level
, box
->z
, box
->depth
,
147 box
->y
+ box
->height
,
148 clear_depth
&& z_res
, depth
,
149 clear_stencil
&& stencil_res
? 0xff : 0, stencil
);
151 blorp_batch_finish(&blorp_batch
);
152 iris_flush_and_dirty_for_history(ice
, batch
, res
);
155 iris_resource_finish_depth(ice
, z_res
, level
,
156 box
->z
, box
->depth
, true);
161 * The pipe->clear() driver hook.
163 * This clears buffers attached to the current draw framebuffer.
166 iris_clear(struct pipe_context
*ctx
,
168 const union pipe_color_union
*p_color
,
172 struct iris_context
*ice
= (void *) ctx
;
173 struct pipe_framebuffer_state
*cso_fb
= &ice
->state
.framebuffer
;
175 assert(buffers
!= 0);
177 if (buffers
& PIPE_CLEAR_DEPTHSTENCIL
) {
178 struct pipe_surface
*psurf
= cso_fb
->zsbuf
;
179 struct pipe_box box
= {
180 .width
= cso_fb
->width
,
181 .height
= cso_fb
->height
,
182 .depth
= psurf
->u
.tex
.last_layer
- psurf
->u
.tex
.first_layer
+ 1,
183 .z
= psurf
->u
.tex
.first_layer
,
186 clear_depth_stencil(ice
, psurf
->texture
, psurf
->u
.tex
.level
, &box
, true,
187 buffers
& PIPE_CLEAR_DEPTH
,
188 buffers
& PIPE_CLEAR_STENCIL
,
192 if (buffers
& PIPE_CLEAR_COLOR
) {
193 /* pipe_color_union and isl_color_value are interchangeable */
194 union isl_color_value
*color
= (void *) p_color
;
196 for (unsigned i
= 0; i
< cso_fb
->nr_cbufs
; i
++) {
197 if (buffers
& (PIPE_CLEAR_COLOR0
<< i
)) {
198 struct pipe_surface
*psurf
= cso_fb
->cbufs
[i
];
199 struct iris_surface
*isurf
= (void *) psurf
;
200 struct pipe_box box
= {
201 .width
= cso_fb
->width
,
202 .height
= cso_fb
->height
,
203 .depth
= psurf
->u
.tex
.last_layer
- psurf
->u
.tex
.first_layer
+ 1,
204 .z
= psurf
->u
.tex
.first_layer
,
207 clear_color(ice
, psurf
->texture
, psurf
->u
.tex
.level
, &box
,
208 true, isurf
->view
.format
, *color
);
215 * The pipe->clear_texture() driver hook.
217 * This clears the given texture resource.
220 iris_clear_texture(struct pipe_context
*ctx
,
221 struct pipe_resource
*p_res
,
223 const struct pipe_box
*box
,
226 struct iris_context
*ice
= (void *) ctx
;
227 struct iris_screen
*screen
= (void *) ctx
->screen
;
228 const struct gen_device_info
*devinfo
= &screen
->devinfo
;
230 if (util_format_is_depth_or_stencil(p_res
->format
)) {
231 const struct util_format_description
*fmt_desc
=
232 util_format_description(p_res
->format
);
237 if (fmt_desc
->unpack_z_float
)
238 fmt_desc
->unpack_z_float(&depth
, 0, data
, 0, 1, 1);
240 if (fmt_desc
->unpack_s_8uint
)
241 fmt_desc
->unpack_s_8uint(&stencil
, 0, data
, 0, 1, 1);
243 clear_depth_stencil(ice
, p_res
, level
, box
, true, true, true,
246 union isl_color_value color
;
247 struct iris_resource
*res
= (void *) p_res
;
248 enum isl_format format
= res
->surf
.format
;
250 if (!isl_format_supports_rendering(devinfo
, format
)) {
251 const struct isl_format_layout
*fmtl
= isl_format_get_layout(format
);
252 // XXX: actually just get_copy_format_for_bpb from BLORP
253 // XXX: don't cut and paste this
255 case 8: format
= ISL_FORMAT_R8_UINT
; break;
256 case 16: format
= ISL_FORMAT_R8G8_UINT
; break;
257 case 24: format
= ISL_FORMAT_R8G8B8_UINT
; break;
258 case 32: format
= ISL_FORMAT_R8G8B8A8_UINT
; break;
259 case 48: format
= ISL_FORMAT_R16G16B16_UINT
; break;
260 case 64: format
= ISL_FORMAT_R16G16B16A16_UINT
; break;
261 case 96: format
= ISL_FORMAT_R32G32B32_UINT
; break;
262 case 128: format
= ISL_FORMAT_R32G32B32A32_UINT
; break;
264 unreachable("Unknown format bpb");
267 /* No aux surfaces for non-renderable surfaces */
268 assert(res
->aux
.usage
== ISL_AUX_USAGE_NONE
);
271 isl_color_value_unpack(&color
, format
, data
);
273 clear_color(ice
, p_res
, level
, box
, true, format
, color
);
278 * The pipe->clear_render_target() driver hook.
280 * This clears the given render target surface.
283 iris_clear_render_target(struct pipe_context
*ctx
,
284 struct pipe_surface
*psurf
,
285 const union pipe_color_union
*p_color
,
286 unsigned dst_x
, unsigned dst_y
,
287 unsigned width
, unsigned height
,
288 bool render_condition_enabled
)
290 struct iris_context
*ice
= (void *) ctx
;
291 struct iris_surface
*isurf
= (void *) psurf
;
292 struct pipe_box box
= {
295 .z
= psurf
->u
.tex
.first_layer
,
298 .depth
= psurf
->u
.tex
.last_layer
- psurf
->u
.tex
.first_layer
+ 1
301 /* pipe_color_union and isl_color_value are interchangeable */
302 union isl_color_value
*color
= (void *) p_color
;
304 clear_color(ice
, psurf
->texture
, psurf
->u
.tex
.level
, &box
,
305 render_condition_enabled
,
306 isurf
->view
.format
, *color
);
310 * The pipe->clear_depth_stencil() driver hook.
312 * This clears the given depth/stencil surface.
315 iris_clear_depth_stencil(struct pipe_context
*ctx
,
316 struct pipe_surface
*psurf
,
320 unsigned dst_x
, unsigned dst_y
,
321 unsigned width
, unsigned height
,
322 bool render_condition_enabled
)
324 struct iris_context
*ice
= (void *) ctx
;
325 struct pipe_box box
= {
328 .z
= psurf
->u
.tex
.first_layer
,
331 .depth
= psurf
->u
.tex
.last_layer
- psurf
->u
.tex
.first_layer
+ 1
334 assert(util_format_is_depth_or_stencil(psurf
->texture
->format
));
336 clear_depth_stencil(ice
, psurf
->texture
, psurf
->u
.tex
.level
, &box
,
337 render_condition_enabled
,
338 flags
& PIPE_CLEAR_DEPTH
, flags
& PIPE_CLEAR_STENCIL
,
343 iris_init_clear_functions(struct pipe_context
*ctx
)
345 ctx
->clear
= iris_clear
;
346 ctx
->clear_texture
= iris_clear_texture
;
347 ctx
->clear_render_target
= iris_clear_render_target
;
348 ctx
->clear_depth_stencil
= iris_clear_depth_stencil
;