X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fstate_tracker%2Fst_cb_fbo.c;h=2455a351c49a65108f757a06a2a29b934a3da878;hb=584f27326c1560cc23538cb76fb734ab492ccc3c;hp=4619aec0c77d6b36d39131af5923c38cd0092a82;hpb=9dc6f76e4423b8b8d3d40c046032a58f72f47de0;p=mesa.git diff --git a/src/mesa/state_tracker/st_cb_fbo.c b/src/mesa/state_tracker/st_cb_fbo.c index 4619aec0c77..2455a351c49 100644 --- a/src/mesa/state_tracker/st_cb_fbo.c +++ b/src/mesa/state_tracker/st_cb_fbo.c @@ -1,8 +1,8 @@ /************************************************************************** - * - * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. + * + * Copyright 2007 VMware, Inc. * All Rights Reserved. - * + * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including @@ -10,19 +10,19 @@ * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: - * + * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. - * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR + * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * + * **************************************************************************/ @@ -33,25 +33,30 @@ */ -#include "main/imports.h" + #include "main/context.h" #include "main/fbobject.h" #include "main/framebuffer.h" +#include "main/glformats.h" #include "main/macros.h" #include "main/renderbuffer.h" +#include "main/state.h" #include "pipe/p_context.h" #include "pipe/p_defines.h" #include "pipe/p_screen.h" +#include "st_atom.h" #include "st_context.h" +#include "st_cb_bufferobjects.h" #include "st_cb_fbo.h" #include "st_cb_flush.h" #include "st_cb_texture.h" #include "st_format.h" #include "st_texture.h" +#include "st_util.h" #include "st_manager.h" -#include "util/u_format.h" +#include "util/format/u_format.h" #include "util/u_inlines.h" #include "util/u_surface.h" @@ -79,7 +84,7 @@ st_renderbuffer_alloc_sw_storage(struct gl_context * ctx, format = PIPE_FORMAT_R16G16B16A16_SNORM; } else { - format = st_choose_renderbuffer_format(st, internalFormat, 0); + format = st_choose_renderbuffer_format(st, internalFormat, 0, 0); /* Not setting gl_renderbuffer::Format here will cause * FRAMEBUFFER_UNSUPPORTED and ValidateFramebuffer will not be called. @@ -109,11 +114,9 @@ st_renderbuffer_alloc_storage(struct gl_context * ctx, GLuint width, GLuint height) { struct st_context *st = st_context(ctx); - struct pipe_context *pipe = st->pipe; struct pipe_screen *screen = st->pipe->screen; struct st_renderbuffer *strb = st_renderbuffer(rb); enum pipe_format format = PIPE_FORMAT_NONE; - struct pipe_surface surf_tmpl; struct pipe_resource templ; /* init renderbuffer fields */ @@ -129,8 +132,17 @@ st_renderbuffer_alloc_storage(struct gl_context * ctx, /* Free the old surface and texture */ - pipe_surface_reference( &strb->surface, NULL ); - pipe_resource_reference( &strb->texture, NULL ); + pipe_surface_reference(&strb->surface_srgb, NULL); + pipe_surface_reference(&strb->surface_linear, NULL); + strb->surface = NULL; + pipe_resource_reference(&strb->texture, NULL); + + /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear + * formats. + */ + if (!ctx->Extensions.EXT_sRGB) { + internalFormat = _mesa_get_linear_internalformat(internalFormat); + } /* Handle multisample renderbuffers first. * @@ -145,22 +157,73 @@ st_renderbuffer_alloc_storage(struct gl_context * ctx, * to and no more than the next larger sample count supported * by the implementation. * - * So let's find the supported number of samples closest to NumSamples. - * (NumSamples == 1) is treated the same as (NumSamples == 0). + * Find the supported number of samples >= rb->NumSamples */ - if (rb->NumSamples > 1) { - unsigned i; - - for (i = rb->NumSamples; i <= ctx->Const.MaxSamples; i++) { - format = st_choose_renderbuffer_format(st, internalFormat, i); + if (rb->NumSamples > 0) { + unsigned start, start_storage; + + if (ctx->Const.MaxSamples > 1 && rb->NumSamples == 1) { + /* don't try num_samples = 1 with drivers that support real msaa */ + start = 2; + start_storage = 2; + } else { + start = rb->NumSamples; + start_storage = rb->NumStorageSamples; + } - if (format != PIPE_FORMAT_NONE) { - rb->NumSamples = i; - break; + if (ctx->Extensions.AMD_framebuffer_multisample_advanced) { + if (rb->_BaseFormat == GL_DEPTH_COMPONENT || + rb->_BaseFormat == GL_DEPTH_STENCIL || + rb->_BaseFormat == GL_STENCIL_INDEX) { + /* Find a supported depth-stencil format. */ + for (unsigned samples = start; + samples <= ctx->Const.MaxDepthStencilFramebufferSamples; + samples++) { + format = st_choose_renderbuffer_format(st, internalFormat, + samples, samples); + + if (format != PIPE_FORMAT_NONE) { + rb->NumSamples = samples; + rb->NumStorageSamples = samples; + break; + } + } + } else { + /* Find a supported color format, samples >= storage_samples. */ + for (unsigned storage_samples = start_storage; + storage_samples <= ctx->Const.MaxColorFramebufferStorageSamples; + storage_samples++) { + for (unsigned samples = MAX2(start, storage_samples); + samples <= ctx->Const.MaxColorFramebufferSamples; + samples++) { + format = st_choose_renderbuffer_format(st, internalFormat, + samples, + storage_samples); + + if (format != PIPE_FORMAT_NONE) { + rb->NumSamples = samples; + rb->NumStorageSamples = storage_samples; + goto found; + } + } + } + found:; + } + } else { + for (unsigned samples = start; samples <= ctx->Const.MaxSamples; + samples++) { + format = st_choose_renderbuffer_format(st, internalFormat, + samples, samples); + + if (format != PIPE_FORMAT_NONE) { + rb->NumSamples = samples; + rb->NumStorageSamples = samples; + break; + } } } } else { - format = st_choose_renderbuffer_format(st, internalFormat, 0); + format = st_choose_renderbuffer_format(st, internalFormat, 0, 0); } /* Not setting gl_renderbuffer::Format here will cause @@ -187,6 +250,8 @@ st_renderbuffer_alloc_storage(struct gl_context * ctx, templ.depth0 = 1; templ.array_size = 1; templ.nr_samples = rb->NumSamples; + templ.nr_storage_samples = rb->NumStorageSamples; + if (util_format_is_depth_or_stencil(format)) { templ.bind = PIPE_BIND_DEPTH_STENCIL; } @@ -205,17 +270,7 @@ st_renderbuffer_alloc_storage(struct gl_context * ctx, if (!strb->texture) return FALSE; - u_surface_default_template(&surf_tmpl, strb->texture); - strb->surface = pipe->create_surface(pipe, - strb->texture, - &surf_tmpl); - if (strb->surface) { - assert(strb->surface->texture); - assert(strb->surface->format); - assert(strb->surface->width == width); - assert(strb->surface->height == height); - } - + st_update_renderbuffer_surface(st, strb); return strb->surface != NULL; } @@ -229,25 +284,19 @@ st_renderbuffer_delete(struct gl_context *ctx, struct gl_renderbuffer *rb) struct st_renderbuffer *strb = st_renderbuffer(rb); if (ctx) { struct st_context *st = st_context(ctx); - pipe_surface_release(st->pipe, &strb->surface); + pipe_surface_release(st->pipe, &strb->surface_srgb); + pipe_surface_release(st->pipe, &strb->surface_linear); + } else { + pipe_surface_release_no_context(&strb->surface_srgb); + pipe_surface_release_no_context(&strb->surface_linear); } + strb->surface = NULL; pipe_resource_reference(&strb->texture, NULL); free(strb->data); _mesa_delete_renderbuffer(ctx, rb); } -/** - * Called via ctx->Driver.NewFramebuffer() - */ -static struct gl_framebuffer * -st_new_framebuffer(struct gl_context *ctx, GLuint name) -{ - /* XXX not sure we need to subclass gl_framebuffer for pipe */ - return _mesa_new_framebuffer(ctx, name); -} - - /** * Called via ctx->Driver.NewRenderbuffer() */ @@ -267,11 +316,11 @@ st_new_renderbuffer(struct gl_context *ctx, GLuint name) /** - * Allocate a renderbuffer for a an on-screen window (not a user-created + * Allocate a renderbuffer for an on-screen window (not a user-created * renderbuffer). The window system code determines the format. */ struct gl_renderbuffer * -st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) +st_new_renderbuffer_fb(enum pipe_format format, unsigned samples, boolean sw) { struct st_renderbuffer *strb; @@ -284,11 +333,20 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) _mesa_init_renderbuffer(&strb->Base, 0); strb->Base.ClassID = 0x4242; /* just a unique value */ strb->Base.NumSamples = samples; + strb->Base.NumStorageSamples = samples; strb->Base.Format = st_pipe_format_to_mesa_format(format); strb->Base._BaseFormat = _mesa_get_format_base_format(strb->Base.Format); strb->software = sw; - + switch (format) { + case PIPE_FORMAT_B10G10R10A2_UNORM: + case PIPE_FORMAT_R10G10B10A2_UNORM: + strb->Base.InternalFormat = GL_RGB10_A2; + break; + case PIPE_FORMAT_R10G10B10X2_UNORM: + case PIPE_FORMAT_B10G10R10X2_UNORM: + strb->Base.InternalFormat = GL_RGB10; + break; case PIPE_FORMAT_R8G8B8A8_UNORM: case PIPE_FORMAT_B8G8R8A8_UNORM: case PIPE_FORMAT_A8R8G8B8_UNORM: @@ -297,8 +355,19 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) case PIPE_FORMAT_R8G8B8X8_UNORM: case PIPE_FORMAT_B8G8R8X8_UNORM: case PIPE_FORMAT_X8R8G8B8_UNORM: + case PIPE_FORMAT_R8G8B8_UNORM: strb->Base.InternalFormat = GL_RGB8; break; + case PIPE_FORMAT_R8G8B8A8_SRGB: + case PIPE_FORMAT_B8G8R8A8_SRGB: + case PIPE_FORMAT_A8R8G8B8_SRGB: + strb->Base.InternalFormat = GL_SRGB8_ALPHA8; + break; + case PIPE_FORMAT_R8G8B8X8_SRGB: + case PIPE_FORMAT_B8G8R8X8_SRGB: + case PIPE_FORMAT_X8R8G8B8_SRGB: + strb->Base.InternalFormat = GL_SRGB8; + break; case PIPE_FORMAT_B5G5R5A1_UNORM: strb->Base.InternalFormat = GL_RGB5_A1; break; @@ -332,6 +401,9 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) case PIPE_FORMAT_R16G16B16A16_UNORM: strb->Base.InternalFormat = GL_RGBA16; break; + case PIPE_FORMAT_R16G16B16_UNORM: + strb->Base.InternalFormat = GL_RGB16; + break; case PIPE_FORMAT_R8_UNORM: strb->Base.InternalFormat = GL_R8; break; @@ -347,12 +419,19 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) case PIPE_FORMAT_R32G32B32A32_FLOAT: strb->Base.InternalFormat = GL_RGBA32F; break; + case PIPE_FORMAT_R32G32B32X32_FLOAT: + case PIPE_FORMAT_R32G32B32_FLOAT: + strb->Base.InternalFormat = GL_RGB32F; + break; case PIPE_FORMAT_R16G16B16A16_FLOAT: strb->Base.InternalFormat = GL_RGBA16F; break; + case PIPE_FORMAT_R16G16B16X16_FLOAT: + strb->Base.InternalFormat = GL_RGB16F; + break; default: _mesa_problem(NULL, - "Unexpected format %s in st_new_renderbuffer_fb", + "Unexpected format %s in st_new_renderbuffer_fb", util_format_name(format)); free(strb); return NULL; @@ -370,13 +449,120 @@ st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw) /** - * Called via ctx->Driver.BindFramebufferEXT(). + * Create or update the pipe_surface of a FBO renderbuffer. + * This is usually called after st_finalize_texture. */ -static void -st_bind_framebuffer(struct gl_context *ctx, GLenum target, - struct gl_framebuffer *fb, struct gl_framebuffer *fbread) +void +st_update_renderbuffer_surface(struct st_context *st, + struct st_renderbuffer *strb) +{ + struct pipe_context *pipe = st->pipe; + struct pipe_resource *resource = strb->texture; + const struct st_texture_object *stTexObj = NULL; + unsigned rtt_width = strb->Base.Width; + unsigned rtt_height = strb->Base.Height; + unsigned rtt_depth = strb->Base.Depth; + + /* + * For winsys fbo, it is possible that the renderbuffer is sRGB-capable but + * the format of strb->texture is linear (because we have no control over + * the format). Check strb->Base.Format instead of strb->texture->format + * to determine if the rb is sRGB-capable. + */ + boolean enable_srgb = st->ctx->Color.sRGBEnabled && + _mesa_is_format_srgb(strb->Base.Format); + enum pipe_format format = resource->format; + + if (strb->is_rtt) { + stTexObj = st_texture_object(strb->Base.TexImage->TexObject); + if (stTexObj->surface_based) + format = stTexObj->surface_format; + } + + format = enable_srgb ? util_format_srgb(format) : util_format_linear(format); + + if (resource->target == PIPE_TEXTURE_1D_ARRAY) { + rtt_depth = rtt_height; + rtt_height = 1; + } + + /* find matching mipmap level size */ + unsigned level; + for (level = 0; level <= resource->last_level; level++) { + if (u_minify(resource->width0, level) == rtt_width && + u_minify(resource->height0, level) == rtt_height && + (resource->target != PIPE_TEXTURE_3D || + u_minify(resource->depth0, level) == rtt_depth)) { + break; + } + } + assert(level <= resource->last_level); + + /* determine the layer bounds */ + unsigned first_layer, last_layer; + if (strb->rtt_layered) { + first_layer = 0; + last_layer = util_max_layer(strb->texture, level); + } + else { + first_layer = + last_layer = strb->rtt_face + strb->rtt_slice; + } + + /* Adjust for texture views */ + if (strb->is_rtt && resource->array_size > 1 && + stTexObj->base.Immutable) { + const struct gl_texture_object *tex = &stTexObj->base; + first_layer += tex->MinLayer; + if (!strb->rtt_layered) + last_layer += tex->MinLayer; + else + last_layer = MIN2(first_layer + tex->NumLayers - 1, last_layer); + } + + struct pipe_surface **psurf = + enable_srgb ? &strb->surface_srgb : &strb->surface_linear; + struct pipe_surface *surf = *psurf; + + if (!surf || + surf->texture->nr_samples != strb->Base.NumSamples || + surf->texture->nr_storage_samples != strb->Base.NumStorageSamples || + surf->format != format || + surf->texture != resource || + surf->width != rtt_width || + surf->height != rtt_height || + surf->nr_samples != strb->rtt_nr_samples || + surf->u.tex.level != level || + surf->u.tex.first_layer != first_layer || + surf->u.tex.last_layer != last_layer) { + /* create a new pipe_surface */ + struct pipe_surface surf_tmpl; + memset(&surf_tmpl, 0, sizeof(surf_tmpl)); + surf_tmpl.format = format; + surf_tmpl.nr_samples = strb->rtt_nr_samples; + surf_tmpl.u.tex.level = level; + surf_tmpl.u.tex.first_layer = first_layer; + surf_tmpl.u.tex.last_layer = last_layer; + + pipe_surface_release(pipe, psurf); + + *psurf = pipe->create_surface(pipe, resource, &surf_tmpl); + } + strb->surface = *psurf; +} + + +/** + * Return the pipe_resource which stores a particular texture image. + */ +static struct pipe_resource * +get_teximage_resource(struct gl_texture_object *texObj, + unsigned face, unsigned level) { - /* no-op */ + struct st_texture_image *stImg = + st_texture_image(texObj->Image[face][level]); + + return stImg->pt; } @@ -389,80 +575,31 @@ st_render_texture(struct gl_context *ctx, struct gl_renderbuffer_attachment *att) { struct st_context *st = st_context(ctx); - struct pipe_context *pipe = st->pipe; - struct st_renderbuffer *strb; - struct gl_renderbuffer *rb; + struct gl_renderbuffer *rb = att->Renderbuffer; + struct st_renderbuffer *strb = st_renderbuffer(rb); struct pipe_resource *pt; - struct st_texture_object *stObj; - const struct gl_texture_image *texImage; - struct pipe_surface surf_tmpl; - - if (!st_finalize_texture(ctx, pipe, att->Texture)) - return; - pt = st_get_texobj_resource(att->Texture); + pt = get_teximage_resource(att->Texture, + att->CubeMapFace, + att->TextureLevel); assert(pt); - /* get pointer to texture image we're rendeing to */ - texImage = _mesa_get_attachment_teximage(att); - - /* create new renderbuffer which wraps the texture image. - * Use the texture's name as the renderbuffer's name so that we have - * something that's non-zero (to determine vertical orientation) and - * possibly helpful for debugging. - */ - rb = st_new_renderbuffer(ctx, att->Texture->Name); - if (!rb) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()"); - return; - } - - _mesa_reference_renderbuffer(&att->Renderbuffer, rb); - assert(rb->RefCount == 1); - rb->AllocStorage = NULL; /* should not get called */ - strb = st_renderbuffer(rb); - - assert(strb->Base.RefCount > 0); - - /* get the texture for the texture object */ - stObj = st_texture_object(att->Texture); - /* point renderbuffer at texobject */ - strb->rtt = stObj; - strb->rtt_level = att->TextureLevel; + strb->is_rtt = TRUE; strb->rtt_face = att->CubeMapFace; strb->rtt_slice = att->Zoffset; + strb->rtt_layered = att->Layered; + strb->rtt_nr_samples = att->NumSamples; + pipe_resource_reference(&strb->texture, pt); - rb->Width = texImage->Width2; - rb->Height = texImage->Height2; - rb->_BaseFormat = texImage->_BaseFormat; - rb->InternalFormat = texImage->InternalFormat; - - pipe_resource_reference( &strb->texture, pt ); - - pipe_surface_release(pipe, &strb->surface); - - assert(strb->rtt_level <= strb->texture->last_level); - - /* new surface for rendering into the texture */ - memset(&surf_tmpl, 0, sizeof(surf_tmpl)); - surf_tmpl.format = ctx->Color.sRGBEnabled - ? strb->texture->format : util_format_linear(strb->texture->format); - surf_tmpl.u.tex.level = strb->rtt_level; - surf_tmpl.u.tex.first_layer = strb->rtt_face + strb->rtt_slice; - surf_tmpl.u.tex.last_layer = strb->rtt_face + strb->rtt_slice; - strb->surface = pipe->create_surface(pipe, - strb->texture, - &surf_tmpl); - - strb->Base.Format = st_pipe_format_to_mesa_format(pt->format); + st_update_renderbuffer_surface(st, strb); /* Invalidate buffer state so that the pipe's framebuffer state * gets updated. * That's where the new renderbuffer (which we just created) gets * passed to the pipe as a (color/depth) render target. */ - st_invalidate_state(ctx, _NEW_BUFFERS); + st_invalidate_buffers(st); /* Need to trigger a call to update_framebuffer() since we just @@ -476,18 +613,18 @@ st_render_texture(struct gl_context *ctx, * Called via ctx->Driver.FinishRenderTexture. */ static void -st_finish_render_texture(struct gl_context *ctx, - struct gl_renderbuffer_attachment *att) +st_finish_render_texture(struct gl_context *ctx, struct gl_renderbuffer *rb) { - struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer); + struct st_context *st = st_context(ctx); + struct st_renderbuffer *strb = st_renderbuffer(rb); if (!strb) return; - strb->rtt = NULL; + strb->is_rtt = FALSE; /* restore previous framebuffer state */ - st_invalidate_state(ctx, _NEW_BUFFERS); + st_invalidate_buffers(st); } @@ -506,15 +643,21 @@ st_fbo_invalid(const char *reason) */ static GLboolean st_validate_attachment(struct gl_context *ctx, - struct pipe_screen *screen, - const struct gl_renderbuffer_attachment *att, - unsigned bindings) + struct pipe_screen *screen, + const struct gl_renderbuffer_attachment *att, + unsigned bindings) { const struct st_texture_object *stObj = st_texture_object(att->Texture); enum pipe_format format; - gl_format texFormat; + mesa_format texFormat; GLboolean valid; + /* Sanity check: we must be binding the surface as a (color) render target + * or depth/stencil target. + */ + assert(bindings == PIPE_BIND_RENDER_TARGET || + bindings == PIPE_BIND_DEPTH_STENCIL); + /* Only validate texture attachments for now, since * st_renderbuffer_alloc_storage makes sure that * the format is supported. @@ -522,31 +665,32 @@ st_validate_attachment(struct gl_context *ctx, if (att->Type != GL_TEXTURE) return GL_TRUE; - if (!stObj) + if (!stObj || !stObj->pt) return GL_FALSE; format = stObj->pt->format; - texFormat = _mesa_get_attachment_teximage_const(att)->TexFormat; + texFormat = att->Renderbuffer->TexImage->TexFormat; /* If the encoding is sRGB and sRGB rendering cannot be enabled, * check for linear format support instead. * Later when we create a surface, we change the format to a linear one. */ - if (!ctx->Extensions.EXT_framebuffer_sRGB && - _mesa_get_format_color_encoding(texFormat) == GL_SRGB) { - const gl_format linearFormat = _mesa_get_srgb_format_linear(texFormat); - format = st_mesa_format_to_pipe_format(linearFormat); + if (!ctx->Extensions.EXT_sRGB && _mesa_is_format_srgb(texFormat)) { + const mesa_format linearFormat = _mesa_get_srgb_format_linear(texFormat); + format = st_mesa_format_to_pipe_format(st_context(ctx), linearFormat); } valid = screen->is_format_supported(screen, format, - PIPE_TEXTURE_2D, - stObj->pt->nr_samples, bindings); + PIPE_TEXTURE_2D, + stObj->pt->nr_samples, + stObj->pt->nr_storage_samples, + bindings); if (!valid) { st_fbo_invalid("Invalid format"); } return valid; } - + /** * Check that the framebuffer configuration is valid in terms of what @@ -588,18 +732,14 @@ st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) return; } - if (!st_validate_attachment(ctx, - screen, - depth, - PIPE_BIND_DEPTH_STENCIL)) { + if (!st_validate_attachment(ctx, screen, depth, PIPE_BIND_DEPTH_STENCIL)) { fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; + st_fbo_invalid("Invalid depth attachment"); return; } - if (!st_validate_attachment(ctx, - screen, - stencil, - PIPE_BIND_DEPTH_STENCIL)) { + if (!st_validate_attachment(ctx, screen, stencil, PIPE_BIND_DEPTH_STENCIL)) { fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; + st_fbo_invalid("Invalid stencil attachment"); return; } for (i = 0; i < ctx->Const.MaxColorAttachments; i++) { @@ -607,12 +747,10 @@ st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) &fb->Attachment[BUFFER_COLOR0 + i]; enum pipe_format format; - if (!st_validate_attachment(ctx, - screen, - att, - PIPE_BIND_RENDER_TARGET)) { - fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; - return; + if (!st_validate_attachment(ctx, screen, att, PIPE_BIND_RENDER_TARGET)) { + fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT; + st_fbo_invalid("Invalid color attachment"); + return; } if (!mixed_formats) { @@ -636,28 +774,60 @@ st_validate_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb) /** - * Called via glDrawBuffer. + * Called by ctx->Driver.DiscardFramebuffer */ static void -st_DrawBuffers(struct gl_context *ctx, GLsizei count, const GLenum *buffers) +st_discard_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb, + struct gl_renderbuffer_attachment *att) +{ + struct st_context *st = st_context(ctx); + struct pipe_resource *prsc; + + if (!att->Renderbuffer || !att->Complete) + return; + + prsc = st_renderbuffer(att->Renderbuffer)->surface->texture; + + /* using invalidate_resource will only work for simple 2D resources */ + if (prsc->depth0 != 1 || prsc->array_size != 1 || prsc->last_level != 0) + return; + + if (st->pipe->invalidate_resource) + st->pipe->invalidate_resource(st->pipe, prsc); +} + + +/** + * Called via glDrawBuffer. We only provide this driver function so that we + * can check if we need to allocate a new renderbuffer. Specifically, we + * don't usually allocate a front color buffer when using a double-buffered + * visual. But if the app calls glDrawBuffer(GL_FRONT) we need to allocate + * that buffer. Note, this is only for window system buffers, not user- + * created FBOs. + */ +static void +st_DrawBufferAllocate(struct gl_context *ctx) { struct st_context *st = st_context(ctx); struct gl_framebuffer *fb = ctx->DrawBuffer; - GLuint i; - (void) count; - (void) buffers; + if (_mesa_is_winsys_fbo(fb)) { + GLuint i; + /* add the renderbuffers on demand */ + for (i = 0; i < fb->_NumColorDrawBuffers; i++) { + gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i]; - /* add the renderbuffers on demand */ - for (i = 0; i < fb->_NumColorDrawBuffers; i++) { - gl_buffer_index idx = fb->_ColorDrawBufferIndexes[i]; - st_manager_add_color_renderbuffer(st, fb, idx); + if (idx != BUFFER_NONE) { + st_manager_add_color_renderbuffer(st, fb, idx); + } + } } } /** - * Called via glReadBuffer. + * Called via glReadBuffer. As with st_DrawBufferAllocate, we use this + * function to check if we need to allocate a renderbuffer on demand. */ static void st_ReadBuffer(struct gl_context *ctx, GLenum buffer) @@ -667,8 +837,19 @@ st_ReadBuffer(struct gl_context *ctx, GLenum buffer) (void) buffer; - /* add the renderbuffer on demand */ - st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex); + /* Check if we need to allocate a front color buffer. + * Front buffers are often allocated on demand (other color buffers are + * always allocated in advance). + */ + if ((fb->_ColorReadBufferIndex == BUFFER_FRONT_LEFT || + fb->_ColorReadBufferIndex == BUFFER_FRONT_RIGHT) && + fb->Attachment[fb->_ColorReadBufferIndex].Type == GL_NONE) { + assert(_mesa_is_winsys_fbo(fb)); + /* add the buffer */ + st_manager_add_color_renderbuffer(st, fb, fb->_ColorReadBufferIndex); + _mesa_update_state(ctx); + st_validate_state(st, ST_PIPELINE_UPDATE_FRAMEBUFFER); + } } @@ -681,13 +862,13 @@ st_MapRenderbuffer(struct gl_context *ctx, struct gl_renderbuffer *rb, GLuint x, GLuint y, GLuint w, GLuint h, GLbitfield mode, - GLubyte **mapOut, GLint *rowStrideOut) + GLubyte **mapOut, GLint *rowStrideOut, + bool flip_y) { struct st_context *st = st_context(ctx); struct st_renderbuffer *strb = st_renderbuffer(rb); struct pipe_context *pipe = st->pipe; - const GLboolean invert = rb->Name == 0; - unsigned usage; + const GLboolean invert = flip_y; GLuint y2; GLubyte *map; @@ -707,13 +888,13 @@ st_MapRenderbuffer(struct gl_context *ctx, return; } - usage = 0x0; - if (mode & GL_MAP_READ_BIT) - usage |= PIPE_TRANSFER_READ; - if (mode & GL_MAP_WRITE_BIT) - usage |= PIPE_TRANSFER_WRITE; - if (mode & GL_MAP_INVALIDATE_RANGE_BIT) - usage |= PIPE_TRANSFER_DISCARD_RANGE; + /* Check for unexpected flags */ + assert((mode & ~(GL_MAP_READ_BIT | + GL_MAP_WRITE_BIT | + GL_MAP_INVALIDATE_RANGE_BIT)) == 0); + + const enum pipe_transfer_usage transfer_flags = + st_access_flags_to_transfer_flags(mode, false); /* Note: y=0=bottom of buffer while y2=0=top of buffer. * 'invert' will be true for window-system buffers and false for @@ -726,9 +907,9 @@ st_MapRenderbuffer(struct gl_context *ctx, map = pipe_transfer_map(pipe, strb->texture, - strb->rtt_level, - strb->rtt_face + strb->rtt_slice, - usage, x, y2, w, h, &strb->transfer); + strb->surface->u.tex.level, + strb->surface->u.tex.first_layer, + transfer_flags, x, y2, w, h, &strb->transfer); if (map) { if (invert) { *rowStrideOut = -(int) strb->transfer->stride; @@ -767,22 +948,35 @@ st_UnmapRenderbuffer(struct gl_context *ctx, } +/** + * Called via ctx->Driver.EvaluateDepthValues. + */ +static void +st_EvaluateDepthValues(struct gl_context *ctx) +{ + struct st_context *st = st_context(ctx); + + st_validate_state(st, ST_PIPELINE_UPDATE_FRAMEBUFFER); + + st->pipe->evaluate_depth_buffer(st->pipe); +} -void st_init_fbo_functions(struct dd_function_table *functions) + +void +st_init_fbo_functions(struct dd_function_table *functions) { - functions->NewFramebuffer = st_new_framebuffer; + functions->NewFramebuffer = _mesa_new_framebuffer; functions->NewRenderbuffer = st_new_renderbuffer; - functions->BindFramebuffer = st_bind_framebuffer; - functions->FramebufferRenderbuffer = _mesa_framebuffer_renderbuffer; + functions->FramebufferRenderbuffer = _mesa_FramebufferRenderbuffer_sw; functions->RenderTexture = st_render_texture; functions->FinishRenderTexture = st_finish_render_texture; functions->ValidateFramebuffer = st_validate_framebuffer; + functions->DiscardFramebuffer = st_discard_framebuffer; - functions->DrawBuffers = st_DrawBuffers; + functions->DrawBufferAllocate = st_DrawBufferAllocate; functions->ReadBuffer = st_ReadBuffer; functions->MapRenderbuffer = st_MapRenderbuffer; functions->UnmapRenderbuffer = st_UnmapRenderbuffer; + functions->EvaluateDepthValues = st_EvaluateDepthValues; } - -