2 * Copyright © 2014 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
24 #include "main/mtypes.h"
25 #include "main/macros.h"
26 #include "main/context.h"
27 #include "main/objectlabel.h"
28 #include "main/shaderapi.h"
29 #include "main/arrayobj.h"
30 #include "main/bufferobj.h"
31 #include "main/buffers.h"
32 #include "main/blend.h"
33 #include "main/enable.h"
34 #include "main/depth.h"
35 #include "main/stencil.h"
36 #include "main/varray.h"
37 #include "main/uniforms.h"
38 #include "main/fbobject.h"
39 #include "main/texobj.h"
41 #include "main/api_validate.h"
42 #include "main/state.h"
44 #include "vbo/vbo_context.h"
46 #include "drivers/common/meta.h"
48 #include "brw_defines.h"
49 #include "brw_context.h"
51 #include "intel_fbo.h"
52 #include "intel_batchbuffer.h"
54 #include "brw_blorp.h"
56 struct brw_fast_clear_state
{
64 brw_fast_clear_init(struct brw_context
*brw
)
66 struct brw_fast_clear_state
*clear
;
68 if (brw
->fast_clear_state
) {
69 clear
= brw
->fast_clear_state
;
70 _mesa_BindVertexArray(clear
->vao
);
71 _mesa_BindBuffer(GL_ARRAY_BUFFER
, clear
->vbo
);
75 brw
->fast_clear_state
= clear
= malloc(sizeof *clear
);
79 memset(clear
, 0, sizeof *clear
);
80 _mesa_GenVertexArrays(1, &clear
->vao
);
81 _mesa_BindVertexArray(clear
->vao
);
82 _mesa_GenBuffers(1, &clear
->vbo
);
83 _mesa_BindBuffer(GL_ARRAY_BUFFER
, clear
->vbo
);
84 _mesa_VertexAttribPointer(0, 2, GL_FLOAT
, GL_FALSE
, sizeof(float) * 2, 0);
85 _mesa_EnableVertexAttribArray(0);
91 brw_bind_rep_write_shader(struct brw_context
*brw
, float *color
)
93 const char *vs_source
=
94 "#extension GL_AMD_vertex_shader_layer : enable\n"
95 "#extension GL_ARB_draw_instanced : enable\n"
96 "attribute vec4 position;\n"
97 "uniform int layer;\n"
100 "#ifdef GL_AMD_vertex_shader_layer\n"
101 " gl_Layer = gl_InstanceID;\n"
103 " gl_Position = position;\n"
105 const char *fs_source
=
106 "uniform vec4 color;\n"
109 " gl_FragColor = color;\n"
113 struct brw_fast_clear_state
*clear
= brw
->fast_clear_state
;
114 struct gl_context
*ctx
= &brw
->ctx
;
116 if (clear
->shader_prog
) {
117 _mesa_UseProgram(clear
->shader_prog
);
118 _mesa_Uniform4fv(clear
->color_location
, 1, color
);
122 vs
= _mesa_meta_compile_shader_with_debug(ctx
, GL_VERTEX_SHADER
, vs_source
);
123 fs
= _mesa_meta_compile_shader_with_debug(ctx
, GL_FRAGMENT_SHADER
, fs_source
);
125 clear
->shader_prog
= _mesa_CreateProgram();
126 _mesa_AttachShader(clear
->shader_prog
, fs
);
127 _mesa_DeleteShader(fs
);
128 _mesa_AttachShader(clear
->shader_prog
, vs
);
129 _mesa_DeleteShader(vs
);
130 _mesa_BindAttribLocation(clear
->shader_prog
, 0, "position");
131 _mesa_ObjectLabel(GL_PROGRAM
, clear
->shader_prog
, -1, "meta repclear");
132 _mesa_LinkProgram(clear
->shader_prog
);
134 clear
->color_location
=
135 _mesa_GetUniformLocation(clear
->shader_prog
, "color");
137 _mesa_UseProgram(clear
->shader_prog
);
138 _mesa_Uniform4fv(clear
->color_location
, 1, color
);
142 brw_meta_fast_clear_free(struct brw_context
*brw
)
144 struct brw_fast_clear_state
*clear
= brw
->fast_clear_state
;
145 GET_CURRENT_CONTEXT(old_context
);
150 _mesa_make_current(&brw
->ctx
, NULL
, NULL
);
152 _mesa_DeleteVertexArrays(1, &clear
->vao
);
153 _mesa_DeleteBuffers(1, &clear
->vbo
);
154 _mesa_DeleteProgram(clear
->shader_prog
);
158 _mesa_make_current(old_context
, old_context
->WinSysDrawBuffer
, old_context
->WinSysReadBuffer
);
160 _mesa_make_current(NULL
, NULL
, NULL
);
168 brw_draw_rectlist(struct gl_context
*ctx
, struct rect
*rect
, int num_instances
)
170 int start
= 0, count
= 3;
171 struct _mesa_prim prim
;
181 /* upload new vertex data */
182 _mesa_BufferData(GL_ARRAY_BUFFER_ARB
, sizeof(verts
), verts
,
183 GL_DYNAMIC_DRAW_ARB
);
186 _mesa_update_state(ctx
);
188 vbo_bind_arrays(ctx
);
190 memset(&prim
, 0, sizeof prim
);
193 prim
.mode
= BRW_PRIM_OFFSET
+ _3DPRIM_RECTLIST
;
194 prim
.num_instances
= num_instances
;
198 /* Make sure our internal prim value doesn't clash with a valid GL value. */
199 assert(!_mesa_is_valid_prim_mode(ctx
, prim
.mode
));
201 brw_draw_prims(ctx
, &prim
, 1, NULL
,
202 GL_TRUE
, start
, start
+ count
- 1,
207 get_fast_clear_rect(struct brw_context
*brw
, struct gl_framebuffer
*fb
,
208 struct intel_renderbuffer
*irb
, struct rect
*rect
)
210 unsigned int x_align
, y_align
;
211 unsigned int x_scaledown
, y_scaledown
;
213 if (irb
->mt
->msaa_layout
== INTEL_MSAA_LAYOUT_NONE
) {
214 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
215 * Target(s)", beneath the "Fast Color Clear" bullet (p327):
217 * Clear pass must have a clear rectangle that must follow
218 * alignment rules in terms of pixels and lines as shown in the
219 * table below. Further, the clear-rectangle height and width
220 * must be multiple of the following dimensions. If the height
221 * and width of the render target being cleared do not meet these
222 * requirements, an MCS buffer can be created such that it
223 * follows the requirement and covers the RT.
225 * The alignment size in the table that follows is related to the
226 * alignment size returned by intel_get_non_msrt_mcs_alignment(), but
227 * with X alignment multiplied by 16 and Y alignment multiplied by 32.
229 intel_get_non_msrt_mcs_alignment(brw
, irb
->mt
, &x_align
, &y_align
);
233 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
234 * Target(s)", beneath the "Fast Color Clear" bullet (p327):
236 * In order to optimize the performance MCS buffer (when bound to
237 * 1X RT) clear similarly to MCS buffer clear for MSRT case,
238 * clear rect is required to be scaled by the following factors
239 * in the horizontal and vertical directions:
241 * The X and Y scale down factors in the table that follows are each
242 * equal to half the alignment value computed above.
244 x_scaledown
= x_align
/ 2;
245 y_scaledown
= y_align
/ 2;
247 /* From BSpec: 3D-Media-GPGPU Engine > 3D Pipeline > Pixel > Pixel
248 * Backend > MCS Buffer for Render Target(s) [DevIVB+] > Table "Color
249 * Clear of Non-MultiSampled Render Target Restrictions":
251 * Clear rectangle must be aligned to two times the number of
252 * pixels in the table shown below due to 16x16 hashing across the
258 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
259 * Target(s)", beneath the "MSAA Compression" bullet (p326):
261 * Clear pass for this case requires that scaled down primitive
262 * is sent down with upper left co-ordinate to coincide with
263 * actual rectangle being cleared. For MSAA, clear rectangle’s
264 * height and width need to as show in the following table in
265 * terms of (width,height) of the RT.
267 * MSAA Width of Clear Rect Height of Clear Rect
268 * 4X Ceil(1/8*width) Ceil(1/2*height)
269 * 8X Ceil(1/2*width) Ceil(1/2*height)
271 * The text "with upper left co-ordinate to coincide with actual
272 * rectangle being cleared" is a little confusing--it seems to imply
273 * that to clear a rectangle from (x,y) to (x+w,y+h), one needs to
274 * feed the pipeline using the rectangle (x,y) to
275 * (x+Ceil(w/N),y+Ceil(h/2)), where N is either 2 or 8 depending on
276 * the number of samples. Experiments indicate that this is not
277 * quite correct; actually, what the hardware appears to do is to
278 * align whatever rectangle is sent down the pipeline to the nearest
279 * multiple of 2x2 blocks, and then scale it up by a factor of N
280 * horizontally and 2 vertically. So the resulting alignment is 4
281 * vertically and either 4 or 16 horizontally, and the scaledown
282 * factor is 2 vertically and either 2 or 8 horizontally.
284 switch (irb
->mt
->num_samples
) {
293 unreachable("Unexpected sample count for fast clear");
296 x_align
= x_scaledown
* 2;
297 y_align
= y_scaledown
* 2;
300 rect
->x0
= fb
->_Xmin
;
301 rect
->x1
= fb
->_Xmax
;
303 rect
->y0
= fb
->_Ymin
;
304 rect
->y1
= fb
->_Ymax
;
306 rect
->y0
= fb
->Height
- fb
->_Ymax
;
307 rect
->y1
= fb
->Height
- fb
->_Ymin
;
310 rect
->x0
= ROUND_DOWN_TO(rect
->x0
, x_align
) / x_scaledown
;
311 rect
->y0
= ROUND_DOWN_TO(rect
->y0
, y_align
) / y_scaledown
;
312 rect
->x1
= ALIGN(rect
->x1
, x_align
) / x_scaledown
;
313 rect
->y1
= ALIGN(rect
->y1
, y_align
) / y_scaledown
;
317 get_buffer_rect(struct brw_context
*brw
, struct gl_framebuffer
*fb
,
318 struct intel_renderbuffer
*irb
, struct rect
*rect
)
320 rect
->x0
= fb
->_Xmin
;
321 rect
->x1
= fb
->_Xmax
;
323 rect
->y0
= fb
->_Ymin
;
324 rect
->y1
= fb
->_Ymax
;
326 rect
->y0
= fb
->Height
- fb
->_Ymax
;
327 rect
->y1
= fb
->Height
- fb
->_Ymin
;
332 * Determine if fast color clear supports the given clear color.
334 * Fast color clear can only clear to color values of 1.0 or 0.0. At the
335 * moment we only support floating point, unorm, and snorm buffers.
338 is_color_fast_clear_compatible(struct brw_context
*brw
,
340 const union gl_color_union
*color
)
342 if (_mesa_is_format_integer_color(format
)) {
344 perf_debug("Integer fast clear not enabled for (%s)",
345 _mesa_get_format_name(format
));
350 for (int i
= 0; i
< 4; i
++) {
351 if (color
->f
[i
] != 0.0 && color
->f
[i
] != 1.0 &&
352 _mesa_format_has_color_component(format
, i
)) {
360 * Convert the given color to a bitfield suitable for ORing into DWORD 7 of
364 compute_fast_clear_color_bits(const union gl_color_union
*color
)
367 for (int i
= 0; i
< 4; i
++) {
368 /* Testing for non-0 works for integer and float colors */
369 if (color
->f
[i
] != 0.0)
370 bits
|= 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT
+ (3 - i
));
375 static const uint32_t fast_clear_color
[4] = { ~0, ~0, ~0, ~0 };
378 set_fast_clear_op(struct brw_context
*brw
, uint32_t op
)
380 /* Set op and dirty BRW_NEW_FRAGMENT_PROGRAM to make sure we re-emit
383 brw
->wm
.fast_clear_op
= op
;
384 brw
->ctx
.NewDriverState
|= BRW_NEW_FRAGMENT_PROGRAM
;
388 use_rectlist(struct brw_context
*brw
, bool enable
)
390 /* Set custom state to let us use _3DPRIM_RECTLIST and the replicated
391 * rendertarget write. When we enable reclist mode, we disable the
392 * viewport transform, disable clipping, enable the rep16 write
393 * optimization and disable simd8 dispatch in the PS.
395 brw
->sf
.viewport_transform_enable
= !enable
;
396 brw
->use_rep_send
= enable
;
397 brw
->no_simd8
= enable
;
399 /* Dirty state to make sure we reemit the state packages affected by the
400 * custom state. We dirty BRW_NEW_FRAGMENT_PROGRAM to emit 3DSTATE_PS for
401 * disabling simd8 dispatch, _NEW_LIGHT to emit 3DSTATE_SF for disabling
402 * the viewport transform and 3DSTATE_CLIP to disable clipping for the
403 * reclist primitive. This is a little messy - it would be nicer to
404 * BRW_NEW_FAST_CLEAR flag or so, but we're out of brw state bits. Dirty
405 * _NEW_BUFFERS to make sure we emit new SURFACE_STATE with the new fast
408 brw
->NewGLState
|= _NEW_LIGHT
| _NEW_BUFFERS
;
409 brw
->ctx
.NewDriverState
|= BRW_NEW_FRAGMENT_PROGRAM
;
413 brw_meta_fast_clear(struct brw_context
*brw
, struct gl_framebuffer
*fb
,
414 GLbitfield buffers
, bool partial_clear
)
416 struct gl_context
*ctx
= &brw
->ctx
;
418 enum { FAST_CLEAR
, REP_CLEAR
, PLAIN_CLEAR
} clear_type
;
419 GLbitfield plain_clear_buffers
, meta_save
, rep_clear_buffers
, fast_clear_buffers
;
420 struct rect fast_clear_rect
, clear_rect
;
423 fast_clear_buffers
= rep_clear_buffers
= plain_clear_buffers
= 0;
425 /* First we loop through the color draw buffers and determine which ones
426 * can be fast cleared, which ones can use the replicated write and which
427 * ones have to fall back to regular color clear.
429 for (unsigned buf
= 0; buf
< fb
->_NumColorDrawBuffers
; buf
++) {
430 struct gl_renderbuffer
*rb
= fb
->_ColorDrawBuffers
[buf
];
431 struct intel_renderbuffer
*irb
= intel_renderbuffer(rb
);
432 int index
= fb
->_ColorDrawBufferIndexes
[buf
];
434 /* Only clear the buffers present in the provided mask */
435 if (((1 << index
) & buffers
) == 0)
438 /* If this is an ES2 context or GL_ARB_ES2_compatibility is supported,
439 * the framebuffer can be complete with some attachments missing. In
440 * this case the _ColorDrawBuffers pointer will be NULL.
445 clear_type
= FAST_CLEAR
;
447 /* We don't have fast clear until gen7. */
449 clear_type
= REP_CLEAR
;
451 if (irb
->mt
->fast_clear_state
== INTEL_FAST_CLEAR_STATE_NO_MCS
)
452 clear_type
= REP_CLEAR
;
454 /* We can't do scissored fast clears because of the restrictions on the
455 * fast clear rectangle size.
458 clear_type
= REP_CLEAR
;
460 /* Fast clear is only supported for colors where all components are
463 format
= _mesa_get_render_format(ctx
, irb
->mt
->format
);
464 if (!is_color_fast_clear_compatible(brw
, format
, &ctx
->Color
.ClearColor
))
465 clear_type
= REP_CLEAR
;
467 /* From the SNB PRM (Vol4_Part1):
469 * "Replicated data (Message Type = 111) is only supported when
470 * accessing tiled memory. Using this Message Type to access
471 * linear (untiled) memory is UNDEFINED."
473 if (irb
->mt
->tiling
== I915_TILING_NONE
) {
474 perf_debug("Falling back to plain clear because %dx%d buffer is untiled\n",
475 irb
->mt
->logical_width0
, irb
->mt
->logical_height0
);
476 clear_type
= PLAIN_CLEAR
;
479 /* Constant color writes ignore everything in blend and color calculator
480 * state. This is not documented.
482 GLubyte
*color_mask
= ctx
->Color
.ColorMask
[buf
];
483 for (int i
= 0; i
< 4; i
++) {
484 if (_mesa_format_has_color_component(irb
->mt
->format
, i
) &&
486 perf_debug("Falling back to plain clear on %dx%d buffer because of color mask\n",
487 irb
->mt
->logical_width0
, irb
->mt
->logical_height0
);
488 clear_type
= PLAIN_CLEAR
;
492 /* Allocate the MCS for non MSRT surfaces now if we're doing a fast
493 * clear and we don't have the MCS yet. On failure, fall back to
496 if (clear_type
== FAST_CLEAR
&& irb
->mt
->mcs_mt
== NULL
)
497 if (!intel_miptree_alloc_non_msrt_mcs(brw
, irb
->mt
))
498 clear_type
= REP_CLEAR
;
500 switch (clear_type
) {
502 irb
->mt
->fast_clear_color_value
=
503 compute_fast_clear_color_bits(&ctx
->Color
.ClearColor
);
504 irb
->need_downsample
= true;
506 /* If the buffer is already in INTEL_FAST_CLEAR_STATE_CLEAR, the
507 * clear is redundant and can be skipped. Only skip after we've
508 * updated the fast clear color above though.
510 if (irb
->mt
->fast_clear_state
== INTEL_FAST_CLEAR_STATE_CLEAR
)
513 /* Set fast_clear_state to RESOLVED so we don't try resolve them when
514 * we draw, in case the mt is also bound as a texture.
516 irb
->mt
->fast_clear_state
= INTEL_FAST_CLEAR_STATE_RESOLVED
;
517 irb
->need_downsample
= true;
518 fast_clear_buffers
|= 1 << index
;
519 get_fast_clear_rect(brw
, fb
, irb
, &fast_clear_rect
);
523 rep_clear_buffers
|= 1 << index
;
524 get_buffer_rect(brw
, fb
, irb
, &clear_rect
);
528 plain_clear_buffers
|= 1 << index
;
529 get_buffer_rect(brw
, fb
, irb
, &clear_rect
);
534 if (!(fast_clear_buffers
| rep_clear_buffers
)) {
535 if (plain_clear_buffers
)
536 /* If we only have plain clears, skip the meta save/restore. */
539 /* Nothing left to do. This happens when we hit the redundant fast
540 * clear case above and nothing else.
546 MESA_META_ALPHA_TEST
|
548 MESA_META_DEPTH_TEST
|
549 MESA_META_RASTERIZATION
|
551 MESA_META_STENCIL_TEST
|
555 MESA_META_CLAMP_FRAGMENT_COLOR
|
556 MESA_META_MULTISAMPLE
|
557 MESA_META_OCCLUSION_QUERY
|
558 MESA_META_DRAW_BUFFERS
;
560 _mesa_meta_begin(ctx
, meta_save
);
562 if (!brw_fast_clear_init(brw
)) {
563 /* This is going to be hard to recover from, most likely out of memory.
564 * Bail and let meta try and (probably) fail for us.
566 plain_clear_buffers
= buffers
;
570 /* Clears never have the color clamped. */
571 if (ctx
->Extensions
.ARB_color_buffer_float
)
572 _mesa_ClampColor(GL_CLAMP_FRAGMENT_COLOR
, GL_FALSE
);
574 _mesa_set_enable(ctx
, GL_DEPTH_TEST
, GL_FALSE
);
575 _mesa_DepthMask(GL_FALSE
);
576 _mesa_set_enable(ctx
, GL_STENCIL_TEST
, GL_FALSE
);
578 use_rectlist(brw
, true);
580 layers
= MAX2(1, fb
->MaxNumLayers
);
581 if (fast_clear_buffers
) {
582 _mesa_meta_drawbuffers_from_bitfield(fast_clear_buffers
);
583 brw_bind_rep_write_shader(brw
, (float *) fast_clear_color
);
584 set_fast_clear_op(brw
, GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE
);
585 brw_draw_rectlist(ctx
, &fast_clear_rect
, layers
);
586 set_fast_clear_op(brw
, 0);
589 if (rep_clear_buffers
) {
590 _mesa_meta_drawbuffers_from_bitfield(rep_clear_buffers
);
591 brw_bind_rep_write_shader(brw
, ctx
->Color
.ClearColor
.f
);
592 brw_draw_rectlist(ctx
, &clear_rect
, layers
);
595 /* Now set the mts we cleared to INTEL_FAST_CLEAR_STATE_CLEAR so we'll
596 * resolve them eventually.
598 for (unsigned buf
= 0; buf
< fb
->_NumColorDrawBuffers
; buf
++) {
599 struct gl_renderbuffer
*rb
= fb
->_ColorDrawBuffers
[buf
];
600 struct intel_renderbuffer
*irb
= intel_renderbuffer(rb
);
601 int index
= fb
->_ColorDrawBufferIndexes
[buf
];
603 if ((1 << index
) & fast_clear_buffers
)
604 irb
->mt
->fast_clear_state
= INTEL_FAST_CLEAR_STATE_CLEAR
;
608 /* Dirty _NEW_BUFFERS so we reemit SURFACE_STATE which sets the fast clear
609 * color before resolve and sets irb->mt->fast_clear_state to UNRESOLVED if
612 brw
->NewGLState
|= _NEW_BUFFERS
;
615 /* Set the custom state back to normal and dirty the same bits as above */
616 use_rectlist(brw
, false);
620 /* From BSpec: Render Target Fast Clear:
622 * After Render target fast clear, pipe-control with color cache
623 * write-flush must be issued before sending any DRAW commands on that
626 brw_emit_mi_flush(brw
);
628 /* If we had to fall back to plain clear for any buffers, clear those now
629 * by calling into meta.
632 if (plain_clear_buffers
)
633 _mesa_meta_glsl_Clear(&brw
->ctx
, plain_clear_buffers
);
639 get_resolve_rect(struct brw_context
*brw
,
640 struct intel_mipmap_tree
*mt
, struct rect
*rect
)
642 unsigned x_align
, y_align
;
643 unsigned x_scaledown
, y_scaledown
;
645 /* From the Ivy Bridge PRM, Vol2 Part1 11.9 "Render Target Resolve":
647 * A rectangle primitive must be scaled down by the following factors
648 * with respect to render target being resolved.
650 * The scaledown factors in the table that follows are related to the
651 * alignment size returned by intel_get_non_msrt_mcs_alignment() by a
652 * multiplier. For IVB and HSW, we divide by two, for BDW we multiply
653 * by 8 and 16 and 8 and 8 for SKL.
656 intel_get_non_msrt_mcs_alignment(brw
, mt
, &x_align
, &y_align
);
658 x_scaledown
= x_align
* 8;
659 y_scaledown
= y_align
* 8;
660 } else if (brw
->gen
>= 8) {
661 x_scaledown
= x_align
* 8;
662 y_scaledown
= y_align
* 16;
664 x_scaledown
= x_align
/ 2;
665 y_scaledown
= y_align
/ 2;
667 rect
->x0
= rect
->y0
= 0;
668 rect
->x1
= ALIGN(mt
->logical_width0
, x_scaledown
) / x_scaledown
;
669 rect
->y1
= ALIGN(mt
->logical_height0
, y_scaledown
) / y_scaledown
;
673 brw_meta_resolve_color(struct brw_context
*brw
,
674 struct intel_mipmap_tree
*mt
)
676 struct gl_context
*ctx
= &brw
->ctx
;
680 brw_emit_mi_flush(brw
);
682 _mesa_meta_begin(ctx
, MESA_META_ALL
);
684 _mesa_GenFramebuffers(1, &fbo
);
685 rbo
= brw_get_rb_for_slice(brw
, mt
, 0, 0, false);
687 _mesa_BindFramebuffer(GL_DRAW_FRAMEBUFFER
, fbo
);
688 _mesa_FramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER
,
689 GL_COLOR_ATTACHMENT0
,
690 GL_RENDERBUFFER
, rbo
);
691 _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0
);
693 brw_fast_clear_init(brw
);
695 use_rectlist(brw
, true);
697 brw_bind_rep_write_shader(brw
, (float *) fast_clear_color
);
699 set_fast_clear_op(brw
, GEN7_PS_RENDER_TARGET_RESOLVE_ENABLE
);
701 mt
->fast_clear_state
= INTEL_FAST_CLEAR_STATE_RESOLVED
;
702 get_resolve_rect(brw
, mt
, &rect
);
704 brw_draw_rectlist(ctx
, &rect
, 1);
706 set_fast_clear_op(brw
, 0);
707 use_rectlist(brw
, false);
709 _mesa_DeleteRenderbuffers(1, &rbo
);
710 _mesa_DeleteFramebuffers(1, &fbo
);
714 /* We're typically called from intel_update_state() and we're supposed to
715 * return with the state all updated to what it was before
716 * brw_meta_resolve_color() was called. The meta rendering will have
717 * messed up the state and we need to call _mesa_update_state() again to
718 * get back to where we were supposed to be when resolve was called.
721 _mesa_update_state(ctx
);