#include "main/enums.h"
#include "main/imports.h"
#include "main/macros.h"
-#include "main/mfeatures.h"
#include "main/mtypes.h"
#include "main/fbobject.h"
#include "main/framebuffer.h"
#include "intel_mipmap_tree.h"
#include "intel_regions.h"
#include "intel_tex.h"
-#include "intel_span.h"
#ifndef I915
#include "brw_context.h"
#endif
return;
}
- /* We sometimes get called with this by our intel_span.c usage. */
- if (!irb->mt) {
- *out_map = NULL;
- *out_stride = 0;
- return;
- }
+ intel_prepare_render(intel);
/* For a window-system renderbuffer, we need to flip the mapping we receive
* upside-down. So we need to ask for a rectangle on flipped vertically, and
return 0;
return 0;
default:
- /* MSAA unsupported. However, a careful reading of
- * EXT_framebuffer_multisample reveals that we need to permit
- * num_samples to be 1 (since num_samples is permitted to be as high as
- * GL_MAX_SAMPLES, and GL_MAX_SAMPLES must be at least 1). Since
- * platforms before Gen6 don't support MSAA, this is safe, because
- * multisampling won't happen anyhow.
- */
- if (num_samples > 0)
- return 1;
+ /* MSAA unsupported. */
return 0;
}
}
irb = intel_renderbuffer(rb);
intel_miptree_release(&irb->mt);
- irb->mt = intel_miptree_create_for_region(intel,
- GL_TEXTURE_2D,
- image->format,
- image->region);
+ irb->mt = intel_miptree_create_for_bo(intel,
+ image->region->bo,
+ image->format,
+ image->offset,
+ image->region->width,
+ image->region->height,
+ image->region->pitch,
+ image->region->tiling);
if (!irb->mt)
return;
rb->Format = image->format;
rb->_BaseFormat = _mesa_base_fbo_format(&intel->ctx,
image->internal_format);
+ rb->NeedsFinishRenderTexture = true;
}
/**
struct intel_mipmap_tree *mt = intel_image->mt;
int level = image->Level;
- rb->Format = image->TexFormat;
- rb->InternalFormat = image->InternalFormat;
- rb->_BaseFormat = image->_BaseFormat;
- rb->Width = mt->level[level].width;
- rb->Height = mt->level[level].height;
+ rb->Depth = image->Depth;
- rb->Delete = intel_delete_renderbuffer;
rb->AllocStorage = intel_nop_alloc_storage;
intel_miptree_check_level_layer(mt, level, layer);
irb->mt_level = level;
- irb->mt_layer = layer;
+
+ switch (mt->msaa_layout) {
+ case INTEL_MSAA_LAYOUT_UMS:
+ case INTEL_MSAA_LAYOUT_CMS:
+ irb->mt_layer = layer * mt->num_samples;
+ break;
+
+ default:
+ irb->mt_layer = layer;
+ }
intel_miptree_reference(&irb->mt, mt);
if (mt->hiz_mt == NULL &&
intel->vtbl.is_hiz_depth_format(intel, rb->Format)) {
- intel_miptree_alloc_hiz(intel, mt, 0 /* num_samples */);
+ intel_miptree_alloc_hiz(intel, mt);
if (!mt->hiz_mt)
return false;
}
irb->draw_y = dst_y;
}
-/**
- * Rendering to tiled buffers requires that the base address of the
- * buffer be aligned to a page boundary. We generally render to
- * textures by pointing the surface at the mipmap image level, which
- * may not be aligned to a tile boundary.
- *
- * This function returns an appropriately-aligned base offset
- * according to the tiling restrictions, plus any required x/y offset
- * from there.
- */
-uint32_t
-intel_renderbuffer_tile_offsets(struct intel_renderbuffer *irb,
- uint32_t *tile_x,
- uint32_t *tile_y)
-{
- struct intel_region *region = irb->mt->region;
- uint32_t mask_x, mask_y;
-
- intel_region_get_tile_masks(region, &mask_x, &mask_y, false);
-
- *tile_x = irb->draw_x & mask_x;
- *tile_y = irb->draw_y & mask_y;
- return intel_region_get_aligned_offset(region, irb->draw_x & ~mask_x,
- irb->draw_y & ~mask_y, false);
-}
-
/**
* Called by glFramebufferTexture[123]DEXT() (and other places) to
* prepare for rendering into texture memory. This might be called
struct gl_renderbuffer_attachment *att)
{
struct intel_context *intel = intel_context(ctx);
- struct gl_texture_image *image = _mesa_get_attachment_teximage(att);
- struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
+ struct gl_renderbuffer *rb = att->Renderbuffer;
+ struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+ struct gl_texture_image *image = rb->TexImage;
struct intel_texture_image *intel_image = intel_texture_image(image);
struct intel_mipmap_tree *mt = intel_image->mt;
int layer;
/* Fallback on drawing to a texture that doesn't have a miptree
* (has a border, width/height 0, etc.)
*/
- _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
_swrast_render_texture(ctx, fb, att);
return;
}
- else if (!irb) {
- intel_miptree_check_level_layer(mt, att->TextureLevel, layer);
-
- irb = (struct intel_renderbuffer *)intel_new_renderbuffer(ctx, ~0);
- if (irb) {
- /* bind the wrapper to the attachment point */
- _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base.Base);
- }
- else {
- /* fallback to software rendering */
- _swrast_render_texture(ctx, fb, att);
- return;
- }
- }
+ intel_miptree_check_level_layer(mt, att->TextureLevel, layer);
if (!intel_renderbuffer_update_wrapper(intel, irb, image, layer)) {
- _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
_swrast_render_texture(ctx, fb, att);
return;
}
- irb->tex_image = image;
-
- DBG("Begin render %s texture tex=%u w=%d h=%d refcount=%d\n",
+ DBG("Begin render %s texture tex=%u w=%d h=%d d=%d refcount=%d\n",
_mesa_get_format_name(image->TexFormat),
- att->Texture->Name, image->Width, image->Height,
- irb->Base.Base.RefCount);
+ att->Texture->Name, image->Width, image->Height, image->Depth,
+ rb->RefCount);
/* update drawing region, etc */
intel_draw_buffer(ctx);
* Called by Mesa when rendering to a texture is done.
*/
static void
-intel_finish_render_texture(struct gl_context * ctx,
- struct gl_renderbuffer_attachment *att)
+intel_finish_render_texture(struct gl_context * ctx, struct gl_renderbuffer *rb)
{
struct intel_context *intel = intel_context(ctx);
- struct gl_texture_object *tex_obj = att->Texture;
- struct gl_texture_image *image =
- tex_obj->Image[att->CubeMapFace][att->TextureLevel];
- struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
- DBG("Finish render %s texture tex=%u\n",
- _mesa_get_format_name(image->TexFormat), att->Texture->Name);
-
- if (irb)
- irb->tex_image = NULL;
+ DBG("Finish render %s texture\n", _mesa_get_format_name(rb->Format));
/* Since we've (probably) rendered to the texture and will (likely) use
* it in the texture domain later on in this batchbuffer, flush the
intel_batchbuffer_emit_mi_flush(intel);
}
+#define fbo_incomplete(fb, ...) do { \
+ static GLuint msg_id = 0; \
+ if (unlikely(ctx->Const.ContextFlags & GL_CONTEXT_FLAG_DEBUG_BIT)) { \
+ _mesa_gl_debug(ctx, &msg_id, \
+ MESA_DEBUG_TYPE_OTHER, \
+ MESA_DEBUG_SEVERITY_MEDIUM, \
+ __VA_ARGS__); \
+ } \
+ DBG(__VA_ARGS__); \
+ fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED; \
+ } while (0)
+
/**
* Do additional "completeness" testing of a framebuffer object.
*/
intel_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
{
struct intel_context *intel = intel_context(ctx);
- const struct intel_renderbuffer *depthRb =
+ struct intel_renderbuffer *depthRb =
intel_get_renderbuffer(fb, BUFFER_DEPTH);
- const struct intel_renderbuffer *stencilRb =
+ struct intel_renderbuffer *stencilRb =
intel_get_renderbuffer(fb, BUFFER_STENCIL);
struct intel_mipmap_tree *depth_mt = NULL, *stencil_mt = NULL;
int i;
*/
if (depthRb->mt_level != stencilRb->mt_level ||
depthRb->mt_layer != stencilRb->mt_layer) {
- DBG("depth image level/layer %d/%d != stencil image %d/%d\n",
- depthRb->mt_level,
- depthRb->mt_layer,
- stencilRb->mt_level,
- stencilRb->mt_layer);
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb,
+ "FBO incomplete: depth image level/layer %d/%d != "
+ "stencil image %d/%d\n",
+ depthRb->mt_level,
+ depthRb->mt_layer,
+ stencilRb->mt_level,
+ stencilRb->mt_layer);
}
} else {
if (!intel->has_separate_stencil) {
- DBG("separate stencil unsupported\n");
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb, "FBO incomplete: separate stencil "
+ "unsupported\n");
}
if (stencil_mt->format != MESA_FORMAT_S8) {
- DBG("separate stencil is %s instead of S8\n",
- _mesa_get_format_name(stencil_mt->format));
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb, "FBO incomplete: separate stencil is %s "
+ "instead of S8\n",
+ _mesa_get_format_name(stencil_mt->format));
}
- if (intel->gen < 7 && depth_mt->hiz_mt == NULL) {
+ if (intel->gen < 7 && !intel_renderbuffer_has_hiz(depthRb)) {
/* Before Gen7, separate depth and stencil buffers can be used
* only if HiZ is enabled. From the Sandybridge PRM, Volume 2,
* Part 1, Bit 3DSTATE_DEPTH_BUFFER.SeparateStencilBufferEnable:
* [DevSNB]: This field must be set to the same value (enabled
* or disabled) as Hierarchical Depth Buffer Enable.
*/
- DBG("separate stencil without HiZ\n");
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED;
+ fbo_incomplete(fb, "FBO incomplete: separate stencil "
+ "without HiZ\n");
}
}
}
*/
rb = fb->Attachment[i].Renderbuffer;
if (rb == NULL) {
- DBG("attachment without renderbuffer\n");
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb, "FBO incomplete: attachment without "
+ "renderbuffer\n");
continue;
}
if (fb->Attachment[i].Type == GL_TEXTURE) {
- const struct gl_texture_image *img =
- _mesa_get_attachment_teximage_const(&fb->Attachment[i]);
-
- if (img->Border) {
- DBG("texture with border\n");
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ if (rb->TexImage->Border) {
+ fbo_incomplete(fb, "FBO incomplete: texture with border\n");
continue;
}
}
irb = intel_renderbuffer(rb);
if (irb == NULL) {
- DBG("software rendering renderbuffer\n");
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb, "FBO incomplete: software rendering "
+ "renderbuffer\n");
continue;
}
if (!intel->vtbl.render_target_supported(intel, rb)) {
- DBG("Unsupported HW texture/renderbuffer format attached: %s\n",
- _mesa_get_format_name(intel_rb_format(irb)));
- fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
+ fbo_incomplete(fb, "FBO incomplete: Unsupported HW "
+ "texture/renderbuffer format attached: %s\n",
+ _mesa_get_format_name(intel_rb_format(irb)));
}
}
}
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
GLbitfield mask, GLenum filter)
{
- /* Try faster, glCopyTexSubImage2D approach first which uses the BLT. */
- mask = intel_blit_framebuffer_copy_tex_sub_image(ctx,
- srcX0, srcY0, srcX1, srcY1,
- dstX0, dstY0, dstX1, dstY1,
- mask, filter);
- if (mask == 0x0)
- return;
-
#ifndef I915
mask = brw_blorp_framebuffer(intel_context(ctx),
srcX0, srcY0, srcX1, srcY1,
return;
#endif
+ /* Try glCopyTexSubImage2D approach which uses the BLT. */
+ mask = intel_blit_framebuffer_copy_tex_sub_image(ctx,
+ srcX0, srcY0, srcX1, srcY1,
+ dstX0, dstY0, dstX1, dstY1,
+ mask, filter);
+ if (mask == 0x0)
+ return;
+
+
_mesa_meta_BlitFramebuffer(ctx,
srcX0, srcY0, srcX1, srcY1,
dstX0, dstY0, dstX1, dstY1,
irb->mt->need_downsample = true;
}
+/**
+ * Does the renderbuffer have hiz enabled?
+ */
+bool
+intel_renderbuffer_has_hiz(struct intel_renderbuffer *irb)
+{
+ return intel_miptree_slice_has_hiz(irb->mt, irb->mt_level, irb->mt_layer);
+}
+
void
intel_renderbuffer_set_needs_hiz_resolve(struct intel_renderbuffer *irb)
{
void
intel_renderbuffer_move_to_temp(struct intel_context *intel,
- struct intel_renderbuffer *irb)
+ struct intel_renderbuffer *irb,
+ bool invalidate)
{
- struct intel_texture_image *intel_image =
- intel_texture_image(irb->tex_image);
+ struct gl_renderbuffer *rb =&irb->Base.Base;
+ struct intel_texture_image *intel_image = intel_texture_image(rb->TexImage);
struct intel_mipmap_tree *new_mt;
int width, height, depth;
- intel_miptree_get_dimensions_for_image(irb->tex_image, &width, &height, &depth);
+ intel_miptree_get_dimensions_for_image(rb->TexImage, &width, &height, &depth);
- new_mt = intel_miptree_create(intel, irb->tex_image->TexObject->Target,
+ new_mt = intel_miptree_create(intel, rb->TexImage->TexObject->Target,
intel_image->base.Base.TexFormat,
intel_image->base.Base.Level,
intel_image->base.Base.Level,
width, height, depth,
true,
irb->mt->num_samples,
- false /* force_y_tiling */);
+ INTEL_MIPTREE_TILING_ANY);
+
+ if (intel->vtbl.is_hiz_depth_format(intel, new_mt->format)) {
+ intel_miptree_alloc_hiz(intel, new_mt);
+ }
+
+ intel_miptree_copy_teximage(intel, intel_image, new_mt, invalidate);
- intel_miptree_copy_teximage(intel, intel_image, new_mt);
intel_miptree_reference(&irb->mt, intel_image->mt);
intel_renderbuffer_set_draw_offset(irb);
intel_miptree_release(&new_mt);
projects / mesa.git / blobdiff