* IN THE SOFTWARE.
*/
-extern "C" {
#include "main/teximage.h"
#include "main/blend.h"
#include "main/fbobject.h"
#include "main/renderbuffer.h"
-}
+#include "main/glformats.h"
-#include "glsl/ralloc.h"
+#include "util/ralloc.h"
#include "intel_fbo.h"
#include "brw_blorp.h"
+#include "brw_meta_util.h"
#include "brw_context.h"
#include "brw_eu.h"
#include "brw_state.h"
+#include "nir_builder.h"
+
#define FILE_DEBUG_FLAG DEBUG_BLORP
struct brw_blorp_const_color_prog_key
bool pad[3];
};
-/**
- * Parameters for a blorp operation where the fragment shader outputs a
- * constant color. This is used for both fast color clears and color
- * resolves.
- */
-class brw_blorp_const_color_params : public brw_blorp_params
-{
-public:
- virtual uint32_t get_wm_prog(struct brw_context *brw,
- brw_blorp_prog_data **prog_data) const;
-
-protected:
- brw_blorp_const_color_prog_key wm_prog_key;
-};
-
-class brw_blorp_clear_params : public brw_blorp_const_color_params
-{
-public:
- brw_blorp_clear_params(struct brw_context *brw,
- struct gl_framebuffer *fb,
- struct gl_renderbuffer *rb,
- GLubyte *color_mask,
- bool partial_clear);
-};
-
-
-/**
- * Parameters for a blorp operation that performs a "render target resolve".
- * This is used to resolve pending fast clear pixels before a color buffer is
- * used for texturing, ReadPixels, or scanout.
- */
-class brw_blorp_rt_resolve_params : public brw_blorp_const_color_params
-{
-public:
- brw_blorp_rt_resolve_params(struct brw_context *brw,
- struct intel_mipmap_tree *mt);
-};
-
-
-class brw_blorp_const_color_program
+static void
+brw_blorp_params_get_clear_kernel(struct brw_context *brw,
+ struct brw_blorp_params *params,
+ bool use_replicated_data)
{
-public:
- brw_blorp_const_color_program(struct brw_context *brw,
- const brw_blorp_const_color_prog_key *key);
- ~brw_blorp_const_color_program();
+ struct brw_blorp_const_color_prog_key blorp_key;
+ memset(&blorp_key, 0, sizeof(blorp_key));
+ blorp_key.use_simd16_replicated_data = use_replicated_data;
- const GLuint *compile(struct brw_context *brw, GLuint *program_size);
+ if (brw_search_cache(&brw->cache, BRW_CACHE_BLORP_PROG,
+ &blorp_key, sizeof(blorp_key),
+ ¶ms->wm_prog_kernel, ¶ms->wm_prog_data))
+ return;
- brw_blorp_prog_data prog_data;
+ void *mem_ctx = ralloc_context(NULL);
-private:
- void alloc_regs();
+ nir_builder b;
+ nir_builder_init_simple_shader(&b, NULL, MESA_SHADER_FRAGMENT, NULL);
+ b.shader->info.name = ralloc_strdup(b.shader, "BLORP-clear");
- void *mem_ctx;
- struct brw_context *brw;
- const brw_blorp_const_color_prog_key *key;
- struct brw_compile func;
+ nir_variable *v_color = nir_variable_create(b.shader, nir_var_shader_in,
+ glsl_vec4_type(), "v_color");
+ v_color->data.location = VARYING_SLOT_VAR0;
+ v_color->data.interpolation = INTERP_MODE_FLAT;
- /* Thread dispatch header */
- struct brw_reg R0;
+ nir_variable *frag_color = nir_variable_create(b.shader, nir_var_shader_out,
+ glsl_vec4_type(),
+ "gl_FragColor");
+ frag_color->data.location = FRAG_RESULT_COLOR;
- /* Pixel X/Y coordinates (always in R1). */
- struct brw_reg R1;
+ nir_copy_var(&b, frag_color, v_color);
- /* Register with push constants (a single vec4) */
- struct brw_reg clear_rgba;
+ struct brw_wm_prog_key wm_key;
+ brw_blorp_init_wm_prog_key(&wm_key);
- /* MRF used for render target writes */
- GLuint base_mrf;
-};
+ struct brw_blorp_prog_data prog_data;
+ unsigned program_size;
+ const unsigned *program =
+ brw_blorp_compile_nir_shader(brw, b.shader, &wm_key, use_replicated_data,
+ &prog_data, &program_size);
-brw_blorp_const_color_program::brw_blorp_const_color_program(
- struct brw_context *brw,
- const brw_blorp_const_color_prog_key *key)
- : mem_ctx(ralloc_context(NULL)),
- brw(brw),
- key(key),
- R0(),
- R1(),
- clear_rgba(),
- base_mrf(0)
-{
- brw_init_compile(brw, &func, mem_ctx);
-}
+ brw_upload_cache(&brw->cache, BRW_CACHE_BLORP_PROG,
+ &blorp_key, sizeof(blorp_key),
+ program, program_size,
+ &prog_data, sizeof(prog_data),
+ ¶ms->wm_prog_kernel, ¶ms->wm_prog_data);
-brw_blorp_const_color_program::~brw_blorp_const_color_program()
-{
ralloc_free(mem_ctx);
}
-
-/**
- * Determine if fast color clear supports the given clear color.
- *
- * Fast color clear can only clear to color values of 1.0 or 0.0. At the
- * moment we only support floating point, unorm, and snorm buffers.
- */
static bool
-is_color_fast_clear_compatible(struct brw_context *brw,
- gl_format format,
- const union gl_color_union *color)
+set_write_disables(const struct intel_renderbuffer *irb,
+ const GLubyte *color_mask, bool *color_write_disable)
{
- if (_mesa_is_format_integer_color(format))
- return false;
-
- for (int i = 0; i < 4; i++) {
- if (color->f[i] != 0.0 && color->f[i] != 1.0) {
- perf_debug("Clear color unsupported by fast color clear. "
- "Falling back to slow clear.\n");
- return false;
- }
- }
- return true;
-}
+ /* Format information in the renderbuffer represents the requirements
+ * given by the client. There are cases where the backing miptree uses,
+ * for example, RGBA to represent RGBX. Since the client is only expecting
+ * RGB we can treat alpha as not used and write whatever we like into it.
+ */
+ const GLenum base_format = irb->Base.Base._BaseFormat;
+ const int components = _mesa_base_format_component_count(base_format);
+ bool disables = false;
+ assert(components > 0);
-/**
- * Convert the given color to a bitfield suitable for ORing into DWORD 7 of
- * SURFACE_STATE.
- */
-static uint32_t
-compute_fast_clear_color_bits(const union gl_color_union *color)
-{
- uint32_t bits = 0;
- for (int i = 0; i < 4; i++) {
- if (color->f[i] != 0.0)
- bits |= 1 << (GEN7_SURFACE_CLEAR_COLOR_SHIFT + (3 - i));
+ for (int i = 0; i < components; i++) {
+ color_write_disable[i] = !color_mask[i];
+ disables = disables || !color_mask[i];
}
- return bits;
-}
+ return disables;
+}
-brw_blorp_clear_params::brw_blorp_clear_params(struct brw_context *brw,
- struct gl_framebuffer *fb,
- struct gl_renderbuffer *rb,
- GLubyte *color_mask,
- bool partial_clear)
+static bool
+do_single_blorp_clear(struct brw_context *brw, struct gl_framebuffer *fb,
+ struct gl_renderbuffer *rb, unsigned buf,
+ bool partial_clear, bool encode_srgb, unsigned layer)
{
- struct intel_context *intel = &brw->intel;
- struct gl_context *ctx = &intel->ctx;
+ struct gl_context *ctx = &brw->ctx;
struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+ mesa_format format = irb->mt->format;
- dst.set(brw, irb->mt, irb->mt_level, irb->mt_layer);
+ struct brw_blorp_params params;
+ brw_blorp_params_init(¶ms);
- /* Override the surface format according to the context's sRGB rules. */
- gl_format format = _mesa_get_render_format(ctx, irb->mt->format);
- dst.brw_surfaceformat = brw->render_target_format[format];
+ if (!encode_srgb && _mesa_get_format_color_encoding(format) == GL_SRGB)
+ format = _mesa_get_srgb_format_linear(format);
- x0 = fb->_Xmin;
- x1 = fb->_Xmax;
+ params.x0 = fb->_Xmin;
+ params.x1 = fb->_Xmax;
if (rb->Name != 0) {
- y0 = fb->_Ymin;
- y1 = fb->_Ymax;
+ params.y0 = fb->_Ymin;
+ params.y1 = fb->_Ymax;
} else {
- y0 = rb->Height - fb->_Ymax;
- y1 = rb->Height - fb->_Ymin;
+ params.y0 = rb->Height - fb->_Ymax;
+ params.y1 = rb->Height - fb->_Ymin;
}
- float *push_consts = (float *)&wm_push_consts;
-
- push_consts[0] = ctx->Color.ClearColor.f[0];
- push_consts[1] = ctx->Color.ClearColor.f[1];
- push_consts[2] = ctx->Color.ClearColor.f[2];
- push_consts[3] = ctx->Color.ClearColor.f[3];
+ memcpy(¶ms.wm_inputs, ctx->Color.ClearColor.f, sizeof(float) * 4);
- use_wm_prog = true;
-
- memset(&wm_prog_key, 0, sizeof(wm_prog_key));
-
- wm_prog_key.use_simd16_replicated_data = true;
+ bool use_simd16_replicated_data = true;
/* From the SNB PRM (Vol4_Part1):
*
* accessing tiled memory. Using this Message Type to access linear
* (untiled) memory is UNDEFINED."
*/
- if (irb->mt->region->tiling == I915_TILING_NONE)
- wm_prog_key.use_simd16_replicated_data = false;
+ if (irb->mt->tiling == I915_TILING_NONE)
+ use_simd16_replicated_data = false;
/* Constant color writes ignore everyting in blend and color calculator
* state. This is not documented.
*/
- for (int i = 0; i < 4; i++) {
- if (!color_mask[i]) {
- color_write_disable[i] = true;
- wm_prog_key.use_simd16_replicated_data = false;
- }
- }
-
- /* If we can do this as a fast color clear, do so. */
- if (irb->mt->mcs_state != INTEL_MCS_STATE_NONE && !partial_clear &&
- wm_prog_key.use_simd16_replicated_data &&
- is_color_fast_clear_compatible(brw, format, &ctx->Color.ClearColor)) {
- memset(push_consts, 0xff, 4*sizeof(float));
- fast_clear_op = GEN7_FAST_CLEAR_OP_FAST_CLEAR;
-
- /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
- * Target(s)", beneath the "Fast Color Clear" bullet (p327):
- *
- * Clear pass must have a clear rectangle that must follow alignment
- * rules in terms of pixels and lines as shown in the table
- * below. Further, the clear-rectangle height and width must be
- * multiple of the following dimensions. If the height and width of
- * the render target being cleared do not meet these requirements,
- * an MCS buffer can be created such that it follows the requirement
- * and covers the RT.
- *
- * The alignment size in the table that follows is related to the
- * alignment size returned by intel_get_non_msrt_mcs_alignment(), but
- * with X alignment multiplied by 16 and Y alignment multiplied by 32.
- */
- unsigned x_align, y_align;
- intel_get_non_msrt_mcs_alignment(brw, irb->mt, &x_align, &y_align);
- x_align *= 16;
- y_align *= 32;
- x0 = ROUND_DOWN_TO(x0, x_align);
- y0 = ROUND_DOWN_TO(y0, y_align);
- x1 = ALIGN(x1, x_align);
- y1 = ALIGN(y1, y_align);
-
- /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
- * Target(s)", beneath the "Fast Color Clear" bullet (p327):
- *
- * In order to optimize the performance MCS buffer (when bound to 1X
- * RT) clear similarly to MCS buffer clear for MSRT case, clear rect
- * is required to be scaled by the following factors in the
- * horizontal and vertical directions:
- *
- * The X and Y scale down factors in the table that follows are each
- * equal to half the alignment value computed above.
- */
- unsigned x_scaledown = x_align / 2;
- unsigned y_scaledown = y_align / 2;
- x0 /= x_scaledown;
- y0 /= y_scaledown;
- x1 /= x_scaledown;
- y1 /= y_scaledown;
+ if (set_write_disables(irb, ctx->Color.ColorMask[buf],
+ params.color_write_disable))
+ use_simd16_replicated_data = false;
+
+ if (irb->mt->fast_clear_state != INTEL_FAST_CLEAR_STATE_NO_MCS &&
+ !partial_clear && use_simd16_replicated_data &&
+ brw_is_color_fast_clear_compatible(brw, irb->mt,
+ &ctx->Color.ClearColor)) {
+ memset(¶ms.wm_inputs, 0xff, 4*sizeof(float));
+ params.fast_clear_op = GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE;
+
+ brw_get_fast_clear_rect(brw, fb, irb->mt, ¶ms.x0, ¶ms.y0,
+ ¶ms.x1, ¶ms.y1);
+ } else {
+ brw_meta_get_buffer_rect(fb, ¶ms.x0, ¶ms.y0,
+ ¶ms.x1, ¶ms.y1);
}
-}
-
-
-brw_blorp_rt_resolve_params::brw_blorp_rt_resolve_params(
- struct brw_context *brw,
- struct intel_mipmap_tree *mt)
-{
- dst.set(brw, mt, 0 /* level */, 0 /* layer */);
-
- /* From the Ivy Bridge PRM, Vol2 Part1 11.9 "Render Target Resolve":
- *
- * A rectangle primitive must be scaled down by the following factors
- * with respect to render target being resolved.
- *
- * The scaledown factors in the table that follows are related to the
- * alignment size returned by intel_get_non_msrt_mcs_alignment(), but with
- * X and Y alignment each divided by 2.
- */
- unsigned x_align, y_align;
- intel_get_non_msrt_mcs_alignment(brw, mt, &x_align, &y_align);
- unsigned x_scaledown = x_align / 2;
- unsigned y_scaledown = y_align / 2;
- x0 = y0 = 0;
- x1 = ALIGN(mt->logical_width0, x_scaledown) / x_scaledown;
- y1 = ALIGN(mt->logical_height0, y_scaledown) / y_scaledown;
- fast_clear_op = GEN7_FAST_CLEAR_OP_RESOLVE;
+ brw_blorp_params_get_clear_kernel(brw, ¶ms, use_simd16_replicated_data);
- /* Note: there is no need to initialize push constants because it doesn't
- * matter what data gets dispatched to the render target. However, we must
- * ensure that the fragment shader delivers the data using the "replicated
- * color" message.
- */
- use_wm_prog = true;
- memset(&wm_prog_key, 0, sizeof(wm_prog_key));
- wm_prog_key.use_simd16_replicated_data = true;
-}
+ const bool is_fast_clear =
+ params.fast_clear_op == GEN7_PS_RENDER_TARGET_FAST_CLEAR_ENABLE;
+ if (is_fast_clear) {
+ /* Record the clear color in the miptree so that it will be
+ * programmed in SURFACE_STATE by later rendering and resolve
+ * operations.
+ */
+ const bool color_updated = brw_meta_set_fast_clear_color(
+ brw, irb->mt, &ctx->Color.ClearColor);
+ /* If the buffer is already in INTEL_FAST_CLEAR_STATE_CLEAR, the clear
+ * is redundant and can be skipped.
+ */
+ if (!color_updated &&
+ irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_CLEAR)
+ return true;
-uint32_t
-brw_blorp_const_color_params::get_wm_prog(struct brw_context *brw,
- brw_blorp_prog_data **prog_data)
- const
-{
- uint32_t prog_offset;
- if (!brw_search_cache(&brw->cache, BRW_BLORP_CONST_COLOR_PROG,
- &this->wm_prog_key, sizeof(this->wm_prog_key),
- &prog_offset, prog_data)) {
- brw_blorp_const_color_program prog(brw, &this->wm_prog_key);
- GLuint program_size;
- const GLuint *program = prog.compile(brw, &program_size);
- brw_upload_cache(&brw->cache, BRW_BLORP_CONST_COLOR_PROG,
- &this->wm_prog_key, sizeof(this->wm_prog_key),
- program, program_size,
- &prog.prog_data, sizeof(prog.prog_data),
- &prog_offset, prog_data);
+ /* If the MCS buffer hasn't been allocated yet, we need to allocate
+ * it now.
+ */
+ if (!irb->mt->mcs_mt) {
+ if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt)) {
+ /* MCS allocation failed--probably this will only happen in
+ * out-of-memory conditions. But in any case, try to recover
+ * by falling back to a non-blorp clear technique.
+ */
+ return false;
+ }
+ }
}
- return prog_offset;
-}
-void
-brw_blorp_const_color_program::alloc_regs()
-{
- int reg = 0;
- this->R0 = retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW);
- this->R1 = retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW);
-
- prog_data.first_curbe_grf = reg;
- clear_rgba = retype(brw_vec4_grf(reg++, 0), BRW_REGISTER_TYPE_F);
- reg += BRW_BLORP_NUM_PUSH_CONST_REGS;
-
- /* Make sure we didn't run out of registers */
- assert(reg <= GEN7_MRF_HACK_START);
+ brw_blorp_surface_info_init(brw, ¶ms.dst, irb->mt, irb->mt_level,
+ layer, format, true);
- this->base_mrf = 2;
-}
-
-const GLuint *
-brw_blorp_const_color_program::compile(struct brw_context *brw,
- GLuint *program_size)
-{
- /* Set up prog_data */
- memset(&prog_data, 0, sizeof(prog_data));
- prog_data.persample_msaa_dispatch = false;
+ /* Override the surface format according to the context's sRGB rules. */
+ params.dst.view.format = (enum isl_format)brw->render_target_format[format];
- alloc_regs();
+ const char *clear_type;
+ if (is_fast_clear)
+ clear_type = "fast";
+ else if (use_simd16_replicated_data)
+ clear_type = "replicated";
+ else
+ clear_type = "slow";
- brw_set_compression_control(&func, BRW_COMPRESSION_NONE);
+ DBG("%s (%s) to mt %p level %d layer %d\n", __FUNCTION__, clear_type,
+ irb->mt, irb->mt_level, irb->mt_layer);
- struct brw_reg mrf_rt_write =
- retype(vec16(brw_message_reg(base_mrf)), BRW_REGISTER_TYPE_F);
+ brw_blorp_exec(brw, ¶ms);
- uint32_t mlen, msg_type;
- if (key->use_simd16_replicated_data) {
- /* The message payload is a single register with the low 4 floats/ints
- * filled with the constant clear color.
+ if (is_fast_clear) {
+ /* Now that the fast clear has occurred, put the buffer in
+ * INTEL_FAST_CLEAR_STATE_CLEAR so that we won't waste time doing
+ * redundant clears.
*/
- brw_set_mask_control(&func, BRW_MASK_DISABLE);
- brw_MOV(&func, vec4(brw_message_reg(base_mrf)), clear_rgba);
- brw_set_mask_control(&func, BRW_MASK_ENABLE);
-
- msg_type = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE_REPLICATED;
- mlen = 1;
- } else {
- for (int i = 0; i < 4; i++) {
- /* The message payload is pairs of registers for 16 pixels each of r,
- * g, b, and a.
- */
- brw_set_compression_control(&func, BRW_COMPRESSION_COMPRESSED);
- brw_MOV(&func,
- brw_message_reg(base_mrf + i * 2),
- brw_vec1_grf(clear_rgba.nr, i));
- brw_set_compression_control(&func, BRW_COMPRESSION_NONE);
- }
-
- msg_type = BRW_DATAPORT_RENDER_TARGET_WRITE_SIMD16_SINGLE_SOURCE;
- mlen = 8;
+ irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_CLEAR;
+ } else if (intel_miptree_is_lossless_compressed(brw, irb->mt)) {
+ /* Compressed buffers can be cleared also using normal rep-clear. In
+ * such case they bahave such as if they were drawn using normal 3D
+ * render pipeline, and we simply mark the mcs as dirty.
+ */
+ assert(partial_clear);
+ irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_UNRESOLVED;
}
- /* Now write to the render target and terminate the thread */
- brw_fb_WRITE(&func,
- 16 /* dispatch_width */,
- base_mrf /* msg_reg_nr */,
- mrf_rt_write /* src0 */,
- msg_type,
- BRW_BLORP_RENDERBUFFER_BINDING_TABLE_INDEX,
- mlen,
- 0 /* response_length */,
- true /* eot */,
- false /* header present */);
-
- if (unlikely(INTEL_DEBUG & DEBUG_BLORP)) {
- printf("Native code for BLORP clear:\n");
- brw_dump_compile(&func, stdout, 0, func.next_insn_offset);
- printf("\n");
- }
- return brw_get_program(&func, program_size);
+ return true;
}
+
extern "C" {
bool
brw_blorp_clear_color(struct brw_context *brw, struct gl_framebuffer *fb,
- bool partial_clear)
+ GLbitfield mask, bool partial_clear, bool encode_srgb)
{
- struct gl_context *ctx = &brw->intel.ctx;
-
- /* The constant color clear code doesn't work for multisampled surfaces, so
- * we need to support falling back to other clear mechanisms.
- * Unfortunately, our clear code is based on a bitmask that doesn't
- * distinguish individual color attachments, so we walk the attachments to
- * see if any require fallback, and fall back for all if any of them need
- * to.
- */
- for (unsigned buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
- struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];
+ for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
+ struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
struct intel_renderbuffer *irb = intel_renderbuffer(rb);
- if (irb && irb->mt->msaa_layout != INTEL_MSAA_LAYOUT_NONE)
- return false;
- }
-
- for (unsigned buf = 0; buf < ctx->DrawBuffer->_NumColorDrawBuffers; buf++) {
- struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[buf];
- struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+ /* Only clear the buffers present in the provided mask */
+ if (((1 << fb->_ColorDrawBufferIndexes[buf]) & mask) == 0)
+ continue;
/* If this is an ES2 context or GL_ARB_ES2_compatibility is supported,
* the framebuffer can be complete with some attachments missing. In
if (rb == NULL)
continue;
- brw_blorp_clear_params params(brw, fb, rb, ctx->Color.ColorMask[buf],
- partial_clear);
-
- bool is_fast_clear =
- (params.fast_clear_op == GEN7_FAST_CLEAR_OP_FAST_CLEAR);
- if (is_fast_clear) {
- /* Record the clear color in the miptree so that it will be
- * programmed in SURFACE_STATE by later rendering and resolve
- * operations.
- */
- uint32_t new_color_value =
- compute_fast_clear_color_bits(&ctx->Color.ClearColor);
- if (irb->mt->fast_clear_color_value != new_color_value) {
- irb->mt->fast_clear_color_value = new_color_value;
- brw->state.dirty.brw |= BRW_NEW_SURFACES;
- }
-
- /* If the buffer is already in INTEL_MCS_STATE_CLEAR, the clear is
- * redundant and can be skipped.
- */
- if (irb->mt->mcs_state == INTEL_MCS_STATE_CLEAR)
- continue;
-
- /* If the MCS buffer hasn't been allocated yet, we need to allocate
- * it now.
- */
- if (!irb->mt->mcs_mt) {
- if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt)) {
- /* MCS allocation failed--probably this will only happen in
- * out-of-memory conditions. But in any case, try to recover
- * by falling back to a non-blorp clear technique.
- */
+ if (fb->MaxNumLayers > 0) {
+ unsigned layer_multiplier =
+ (irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_UMS ||
+ irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) ?
+ irb->mt->num_samples : 1;
+ unsigned num_layers = irb->layer_count;
+ for (unsigned layer = 0; layer < num_layers; layer++) {
+ if (!do_single_blorp_clear(
+ brw, fb, rb, buf, partial_clear, encode_srgb,
+ irb->mt_layer + layer * layer_multiplier)) {
return false;
}
- brw->state.dirty.brw |= BRW_NEW_SURFACES;
}
+ } else {
+ unsigned layer = irb->mt_layer;
+ if (!do_single_blorp_clear(brw, fb, rb, buf, partial_clear,
+ encode_srgb, layer))
+ return false;
}
- DBG("%s to mt %p level %d layer %d\n", __FUNCTION__,
- irb->mt, irb->mt_level, irb->mt_layer);
-
- brw_blorp_exec(brw, ¶ms);
-
- if (is_fast_clear) {
- /* Now that the fast clear has occurred, put the buffer in
- * INTEL_MCS_STATE_CLEAR so that we won't waste time doing redundant
- * clears.
- */
- irb->mt->mcs_state = INTEL_MCS_STATE_CLEAR;
- }
+ irb->need_downsample = true;
}
return true;
{
DBG("%s to mt %p\n", __FUNCTION__, mt);
- brw_blorp_rt_resolve_params params(brw, mt);
+ const mesa_format format = _mesa_get_srgb_format_linear(mt->format);
+
+ struct brw_blorp_params params;
+ brw_blorp_params_init(¶ms);
+
+ brw_blorp_surface_info_init(brw, ¶ms.dst, mt,
+ 0 /* level */, 0 /* layer */, format, true);
+
+ brw_get_resolve_rect(brw, mt, ¶ms.x0, ¶ms.y0,
+ ¶ms.x1, ¶ms.y1);
+
+ if (intel_miptree_is_lossless_compressed(brw, mt))
+ params.resolve_type = GEN9_PS_RENDER_TARGET_RESOLVE_FULL;
+ else
+ params.resolve_type = GEN7_PS_RENDER_TARGET_RESOLVE_ENABLE;
+
+ /* Note: there is no need to initialize push constants because it doesn't
+ * matter what data gets dispatched to the render target. However, we must
+ * ensure that the fragment shader delivers the data using the "replicated
+ * color" message.
+ */
+
+ brw_blorp_params_get_clear_kernel(brw, ¶ms, true);
+
brw_blorp_exec(brw, ¶ms);
- mt->mcs_state = INTEL_MCS_STATE_RESOLVED;
+ mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
}
} /* extern "C" */
projects / mesa.git / blobdiff