1 /**************************************************************************
3 * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
29 #include "main/imports.h"
30 #include "main/macros.h"
31 #include "main/mfeatures.h"
32 #include "main/mtypes.h"
33 #include "main/fbobject.h"
34 #include "main/framebuffer.h"
35 #include "main/renderbuffer.h"
36 #include "main/context.h"
37 #include "main/teximage.h"
38 #include "swrast/swrast.h"
39 #include "drivers/common/meta.h"
41 #include "intel_context.h"
42 #include "intel_batchbuffer.h"
43 #include "intel_buffers.h"
44 #include "intel_fbo.h"
45 #include "intel_mipmap_tree.h"
46 #include "intel_regions.h"
47 #include "intel_tex.h"
48 #include "intel_span.h"
50 #include "brw_context.h"
53 #define FILE_DEBUG_FLAG DEBUG_FBO
57 * Create a new framebuffer object.
59 static struct gl_framebuffer
*
60 intel_new_framebuffer(struct gl_context
* ctx
, GLuint name
)
62 /* Only drawable state in intel_framebuffer at this time, just use Mesa's
65 return _mesa_new_framebuffer(ctx
, name
);
69 /** Called by gl_renderbuffer::Delete() */
71 intel_delete_renderbuffer(struct gl_renderbuffer
*rb
)
73 struct intel_renderbuffer
*irb
= intel_renderbuffer(rb
);
77 intel_region_release(&irb
->region
);
78 intel_region_release(&irb
->hiz_region
);
80 _mesa_reference_renderbuffer(&irb
->wrapped_depth
, NULL
);
81 _mesa_reference_renderbuffer(&irb
->wrapped_stencil
, NULL
);
88 * Return a pointer to a specific pixel in a renderbuffer.
91 intel_get_pointer(struct gl_context
* ctx
, struct gl_renderbuffer
*rb
,
94 /* By returning NULL we force all software rendering to go through
102 * Called via glRenderbufferStorageEXT() to set the format and allocate
103 * storage for a user-created renderbuffer.
106 intel_alloc_renderbuffer_storage(struct gl_context
* ctx
, struct gl_renderbuffer
*rb
,
107 GLenum internalFormat
,
108 GLuint width
, GLuint height
)
110 struct intel_context
*intel
= intel_context(ctx
);
111 struct intel_renderbuffer
*irb
= intel_renderbuffer(rb
);
114 ASSERT(rb
->Name
!= 0);
116 switch (internalFormat
) {
118 /* Use the same format-choice logic as for textures.
119 * Renderbuffers aren't any different from textures for us,
120 * except they're less useful because you can't texture with
123 rb
->Format
= intel
->ctx
.Driver
.ChooseTextureFormat(ctx
, internalFormat
,
126 case GL_STENCIL_INDEX
:
127 case GL_STENCIL_INDEX1_EXT
:
128 case GL_STENCIL_INDEX4_EXT
:
129 case GL_STENCIL_INDEX8_EXT
:
130 case GL_STENCIL_INDEX16_EXT
:
131 /* These aren't actual texture formats, so force them here. */
132 if (intel
->has_separate_stencil
) {
133 rb
->Format
= MESA_FORMAT_S8
;
135 assert(!intel
->must_use_separate_stencil
);
136 rb
->Format
= MESA_FORMAT_S8_Z24
;
143 rb
->_BaseFormat
= _mesa_base_fbo_format(ctx
, internalFormat
);
144 rb
->DataType
= intel_mesa_format_to_rb_datatype(rb
->Format
);
145 cpp
= _mesa_get_format_bytes(rb
->Format
);
149 /* free old region */
151 intel_region_release(&irb
->region
);
153 if (irb
->hiz_region
) {
154 intel_region_release(&irb
->hiz_region
);
157 /* allocate new memory region/renderbuffer */
159 /* alloc hardware renderbuffer */
160 DBG("Allocating %d x %d Intel RBO\n", width
, height
);
162 tiling
= I915_TILING_NONE
;
163 if (intel
->use_texture_tiling
) {
164 GLenum base_format
= _mesa_get_format_base_format(rb
->Format
);
166 if (intel
->gen
>= 4 && (base_format
== GL_DEPTH_COMPONENT
||
167 base_format
== GL_STENCIL_INDEX
||
168 base_format
== GL_DEPTH_STENCIL
))
169 tiling
= I915_TILING_Y
;
171 tiling
= I915_TILING_X
;
174 if (irb
->Base
.Format
== MESA_FORMAT_S8
) {
176 * The stencil buffer is W tiled. However, we request from the kernel a
177 * non-tiled buffer because the GTT is incapable of W fencing.
179 * The stencil buffer has quirky pitch requirements. From Vol 2a,
180 * 11.5.6.2.1 3DSTATE_STENCIL_BUFFER, field "Surface Pitch":
181 * The pitch must be set to 2x the value computed based on width, as
182 * the stencil buffer is stored with two rows interleaved.
183 * To accomplish this, we resort to the nasty hack of doubling the drm
184 * region's cpp and halving its height.
186 * If we neglect to double the pitch, then render corruption occurs.
188 irb
->region
= intel_region_alloc(intel
->intelScreen
,
192 ALIGN((height
+ 1) / 2, 64),
197 } else if (irb
->Base
.Format
== MESA_FORMAT_S8_Z24
198 && intel
->must_use_separate_stencil
) {
201 struct gl_renderbuffer
*depth_rb
;
202 struct gl_renderbuffer
*stencil_rb
;
204 depth_rb
= intel_create_wrapped_renderbuffer(ctx
, width
, height
,
206 stencil_rb
= intel_create_wrapped_renderbuffer(ctx
, width
, height
,
208 ok
= depth_rb
&& stencil_rb
;
209 ok
= ok
&& intel_alloc_renderbuffer_storage(ctx
, depth_rb
,
210 depth_rb
->InternalFormat
,
212 ok
= ok
&& intel_alloc_renderbuffer_storage(ctx
, stencil_rb
,
213 stencil_rb
->InternalFormat
,
218 intel_delete_renderbuffer(depth_rb
);
221 intel_delete_renderbuffer(stencil_rb
);
226 depth_rb
->Wrapped
= rb
;
227 stencil_rb
->Wrapped
= rb
;
228 _mesa_reference_renderbuffer(&irb
->wrapped_depth
, depth_rb
);
229 _mesa_reference_renderbuffer(&irb
->wrapped_stencil
, stencil_rb
);
232 irb
->region
= intel_region_alloc(intel
->intelScreen
, tiling
, cpp
,
233 width
, height
, GL_TRUE
);
237 if (intel
->vtbl
.is_hiz_depth_format(intel
, rb
->Format
)) {
238 irb
->hiz_region
= intel_region_alloc(intel
->intelScreen
,
244 if (!irb
->hiz_region
) {
245 intel_region_release(&irb
->region
);
255 #if FEATURE_OES_EGL_image
257 intel_image_target_renderbuffer_storage(struct gl_context
*ctx
,
258 struct gl_renderbuffer
*rb
,
261 struct intel_context
*intel
= intel_context(ctx
);
262 struct intel_renderbuffer
*irb
;
266 screen
= intel
->intelScreen
->driScrnPriv
;
267 image
= screen
->dri2
.image
->lookupEGLImage(screen
, image_handle
,
268 screen
->loaderPrivate
);
272 /* __DRIimage is opaque to the core so it has to be checked here */
273 switch (image
->format
) {
274 case MESA_FORMAT_RGBA8888_REV
:
275 _mesa_error(&intel
->ctx
, GL_INVALID_OPERATION
,
276 "glEGLImageTargetRenderbufferStorage(unsupported image format");
283 irb
= intel_renderbuffer(rb
);
284 intel_region_reference(&irb
->region
, image
->region
);
286 rb
->InternalFormat
= image
->internal_format
;
287 rb
->Width
= image
->region
->width
;
288 rb
->Height
= image
->region
->height
;
289 rb
->Format
= image
->format
;
290 rb
->DataType
= image
->data_type
;
291 rb
->_BaseFormat
= _mesa_base_fbo_format(&intel
->ctx
,
292 image
->internal_format
);
297 * Called for each hardware renderbuffer when a _window_ is resized.
298 * Just update fields.
299 * Not used for user-created renderbuffers!
302 intel_alloc_window_storage(struct gl_context
* ctx
, struct gl_renderbuffer
*rb
,
303 GLenum internalFormat
, GLuint width
, GLuint height
)
305 ASSERT(rb
->Name
== 0);
308 rb
->InternalFormat
= internalFormat
;
315 intel_resize_buffers(struct gl_context
*ctx
, struct gl_framebuffer
*fb
,
316 GLuint width
, GLuint height
)
320 _mesa_resize_framebuffer(ctx
, fb
, width
, height
);
322 fb
->Initialized
= GL_TRUE
; /* XXX remove someday */
329 /* Make sure all window system renderbuffers are up to date */
330 for (i
= BUFFER_FRONT_LEFT
; i
<= BUFFER_BACK_RIGHT
; i
++) {
331 struct gl_renderbuffer
*rb
= fb
->Attachment
[i
].Renderbuffer
;
333 /* only resize if size is changing */
334 if (rb
&& (rb
->Width
!= width
|| rb
->Height
!= height
)) {
335 rb
->AllocStorage(ctx
, rb
, rb
->InternalFormat
, width
, height
);
341 /** Dummy function for gl_renderbuffer::AllocStorage() */
343 intel_nop_alloc_storage(struct gl_context
* ctx
, struct gl_renderbuffer
*rb
,
344 GLenum internalFormat
, GLuint width
, GLuint height
)
346 _mesa_problem(ctx
, "intel_op_alloc_storage should never be called.");
351 * Create a new intel_renderbuffer which corresponds to an on-screen window,
352 * not a user-created renderbuffer.
354 struct intel_renderbuffer
*
355 intel_create_renderbuffer(gl_format format
)
357 GET_CURRENT_CONTEXT(ctx
);
359 struct intel_renderbuffer
*irb
;
361 irb
= CALLOC_STRUCT(intel_renderbuffer
);
363 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "creating renderbuffer");
367 _mesa_init_renderbuffer(&irb
->Base
, 0);
368 irb
->Base
.ClassID
= INTEL_RB_CLASS
;
369 irb
->Base
._BaseFormat
= _mesa_get_format_base_format(format
);
370 irb
->Base
.Format
= format
;
371 irb
->Base
.InternalFormat
= irb
->Base
._BaseFormat
;
372 irb
->Base
.DataType
= intel_mesa_format_to_rb_datatype(format
);
374 /* intel-specific methods */
375 irb
->Base
.Delete
= intel_delete_renderbuffer
;
376 irb
->Base
.AllocStorage
= intel_alloc_window_storage
;
377 irb
->Base
.GetPointer
= intel_get_pointer
;
383 struct gl_renderbuffer
*
384 intel_create_wrapped_renderbuffer(struct gl_context
* ctx
,
385 int width
, int height
,
389 * The name here is irrelevant, as long as its nonzero, because the
390 * renderbuffer never gets entered into Mesa's renderbuffer hash table.
394 struct intel_renderbuffer
*irb
= CALLOC_STRUCT(intel_renderbuffer
);
396 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "creating renderbuffer");
400 struct gl_renderbuffer
*rb
= &irb
->Base
;
401 _mesa_init_renderbuffer(rb
, name
);
402 rb
->ClassID
= INTEL_RB_CLASS
;
403 rb
->_BaseFormat
= _mesa_get_format_base_format(format
);
405 rb
->InternalFormat
= rb
->_BaseFormat
;
406 rb
->DataType
= intel_mesa_format_to_rb_datatype(format
);
415 * Create a new renderbuffer object.
416 * Typically called via glBindRenderbufferEXT().
418 static struct gl_renderbuffer
*
419 intel_new_renderbuffer(struct gl_context
* ctx
, GLuint name
)
421 /*struct intel_context *intel = intel_context(ctx); */
422 struct intel_renderbuffer
*irb
;
424 irb
= CALLOC_STRUCT(intel_renderbuffer
);
426 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "creating renderbuffer");
430 _mesa_init_renderbuffer(&irb
->Base
, name
);
431 irb
->Base
.ClassID
= INTEL_RB_CLASS
;
433 /* intel-specific methods */
434 irb
->Base
.Delete
= intel_delete_renderbuffer
;
435 irb
->Base
.AllocStorage
= intel_alloc_renderbuffer_storage
;
436 irb
->Base
.GetPointer
= intel_get_pointer
;
437 /* span routines set in alloc_storage function */
444 * Called via glBindFramebufferEXT().
447 intel_bind_framebuffer(struct gl_context
* ctx
, GLenum target
,
448 struct gl_framebuffer
*fb
, struct gl_framebuffer
*fbread
)
450 if (target
== GL_FRAMEBUFFER_EXT
|| target
== GL_DRAW_FRAMEBUFFER_EXT
) {
451 intel_draw_buffer(ctx
);
454 /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */
460 * Called via glFramebufferRenderbufferEXT().
463 intel_framebuffer_renderbuffer(struct gl_context
* ctx
,
464 struct gl_framebuffer
*fb
,
465 GLenum attachment
, struct gl_renderbuffer
*rb
)
467 DBG("Intel FramebufferRenderbuffer %u %u\n", fb
->Name
, rb
? rb
->Name
: 0);
471 _mesa_framebuffer_renderbuffer(ctx
, fb
, attachment
, rb
);
472 intel_draw_buffer(ctx
);
476 intel_update_tex_wrapper_regions(struct intel_context
*intel
,
477 struct intel_renderbuffer
*irb
,
478 struct intel_texture_image
*intel_image
);
481 intel_update_wrapper(struct gl_context
*ctx
, struct intel_renderbuffer
*irb
,
482 struct gl_texture_image
*texImage
)
484 struct intel_context
*intel
= intel_context(ctx
);
485 struct intel_texture_image
*intel_image
= intel_texture_image(texImage
);
487 if (!intel_span_supports_format(texImage
->TexFormat
)) {
488 DBG("Render to texture BAD FORMAT %s\n",
489 _mesa_get_format_name(texImage
->TexFormat
));
492 DBG("Render to texture %s\n", _mesa_get_format_name(texImage
->TexFormat
));
495 irb
->Base
.Format
= texImage
->TexFormat
;
496 irb
->Base
.DataType
= intel_mesa_format_to_rb_datatype(texImage
->TexFormat
);
497 irb
->Base
.InternalFormat
= texImage
->InternalFormat
;
498 irb
->Base
._BaseFormat
= _mesa_base_tex_format(ctx
, irb
->Base
.InternalFormat
);
499 irb
->Base
.Width
= texImage
->Width
;
500 irb
->Base
.Height
= texImage
->Height
;
502 irb
->Base
.Delete
= intel_delete_renderbuffer
;
503 irb
->Base
.AllocStorage
= intel_nop_alloc_storage
;
505 if (intel_image
->stencil_rb
) {
506 /* The tex image has packed depth/stencil format, but is using separate
510 struct intel_renderbuffer
*depth_irb
=
511 intel_renderbuffer(intel_image
->depth_rb
);
513 /* Update the hiz region if necessary. */
514 ok
= intel_update_tex_wrapper_regions(intel
, depth_irb
, intel_image
);
519 /* The tex image shares its embedded depth and stencil renderbuffers with
520 * the renderbuffer wrapper. */
521 if (irb
->wrapped_depth
!= intel_image
->depth_rb
) {
522 _mesa_reference_renderbuffer(&irb
->wrapped_depth
,
523 intel_image
->depth_rb
);
525 if (irb
->wrapped_stencil
!= intel_image
->stencil_rb
) {
526 _mesa_reference_renderbuffer(&irb
->wrapped_stencil
,
527 intel_image
->stencil_rb
);
533 return intel_update_tex_wrapper_regions(intel
, irb
, intel_image
);
538 * FIXME: The handling of the hiz region is broken for mipmapped depth textures
539 * FIXME: because intel_finalize_mipmap_tree is unaware of it.
542 intel_update_tex_wrapper_regions(struct intel_context
*intel
,
543 struct intel_renderbuffer
*irb
,
544 struct intel_texture_image
*intel_image
)
546 struct gl_renderbuffer
*rb
= &irb
->Base
;
548 /* Point the renderbuffer's region to the texture's region. */
549 if (irb
->region
!= intel_image
->mt
->region
) {
550 intel_region_reference(&irb
->region
, intel_image
->mt
->region
);
553 /* Allocate the texture's hiz region if necessary. */
554 if (intel
->vtbl
.is_hiz_depth_format(intel
, rb
->Format
)
555 && !intel_image
->mt
->hiz_region
) {
556 intel_image
->mt
->hiz_region
=
557 intel_region_alloc(intel
->intelScreen
,
559 _mesa_get_format_bytes(rb
->Format
),
563 if (!intel_image
->mt
->hiz_region
)
567 /* Point the renderbuffer's hiz region to the texture's hiz region. */
568 if (irb
->hiz_region
!= intel_image
->mt
->hiz_region
) {
569 intel_region_reference(&irb
->hiz_region
, intel_image
->mt
->hiz_region
);
577 * When glFramebufferTexture[123]D is called this function sets up the
578 * gl_renderbuffer wrapper around the texture image.
579 * This will have the region info needed for hardware rendering.
581 static struct intel_renderbuffer
*
582 intel_wrap_texture(struct gl_context
* ctx
, struct gl_texture_image
*texImage
)
584 const GLuint name
= ~0; /* not significant, but distinct for debugging */
585 struct intel_renderbuffer
*irb
;
587 /* make an intel_renderbuffer to wrap the texture image */
588 irb
= CALLOC_STRUCT(intel_renderbuffer
);
590 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glFramebufferTexture");
594 _mesa_init_renderbuffer(&irb
->Base
, name
);
595 irb
->Base
.ClassID
= INTEL_RB_CLASS
;
597 if (!intel_update_wrapper(ctx
, irb
, texImage
)) {
606 intel_renderbuffer_set_draw_offset(struct intel_renderbuffer
*irb
,
607 struct intel_texture_image
*intel_image
,
610 unsigned int dst_x
, dst_y
;
612 /* compute offset of the particular 2D image within the texture region */
613 intel_miptree_get_image_offset(intel_image
->mt
,
614 intel_image
->base
.Base
.Level
,
615 intel_image
->base
.Base
.Face
,
624 * Rendering to tiled buffers requires that the base address of the
625 * buffer be aligned to a page boundary. We generally render to
626 * textures by pointing the surface at the mipmap image level, which
627 * may not be aligned to a tile boundary.
629 * This function returns an appropriately-aligned base offset
630 * according to the tiling restrictions, plus any required x/y offset
634 intel_renderbuffer_tile_offsets(struct intel_renderbuffer
*irb
,
638 int cpp
= irb
->region
->cpp
;
639 uint32_t pitch
= irb
->region
->pitch
* cpp
;
641 if (irb
->region
->tiling
== I915_TILING_NONE
) {
644 return irb
->draw_x
* cpp
+ irb
->draw_y
* pitch
;
645 } else if (irb
->region
->tiling
== I915_TILING_X
) {
646 *tile_x
= irb
->draw_x
% (512 / cpp
);
647 *tile_y
= irb
->draw_y
% 8;
648 return ((irb
->draw_y
/ 8) * (8 * pitch
) +
649 (irb
->draw_x
- *tile_x
) / (512 / cpp
) * 4096);
651 assert(irb
->region
->tiling
== I915_TILING_Y
);
652 *tile_x
= irb
->draw_x
% (128 / cpp
);
653 *tile_y
= irb
->draw_y
% 32;
654 return ((irb
->draw_y
/ 32) * (32 * pitch
) +
655 (irb
->draw_x
- *tile_x
) / (128 / cpp
) * 4096);
661 need_tile_offset_workaround(struct brw_context
*brw
,
662 struct intel_renderbuffer
*irb
)
664 uint32_t tile_x
, tile_y
;
666 if (brw
->has_surface_tile_offset
)
669 intel_renderbuffer_tile_offsets(irb
, &tile_x
, &tile_y
);
671 return tile_x
!= 0 || tile_y
!= 0;
676 * Called by glFramebufferTexture[123]DEXT() (and other places) to
677 * prepare for rendering into texture memory. This might be called
678 * many times to choose different texture levels, cube faces, etc
679 * before intel_finish_render_texture() is ever called.
682 intel_render_texture(struct gl_context
* ctx
,
683 struct gl_framebuffer
*fb
,
684 struct gl_renderbuffer_attachment
*att
)
686 struct gl_texture_image
*image
= _mesa_get_attachment_teximage(att
);
687 struct intel_renderbuffer
*irb
= intel_renderbuffer(att
->Renderbuffer
);
688 struct intel_texture_image
*intel_image
= intel_texture_image(image
);
692 if (!intel_image
->mt
) {
693 /* Fallback on drawing to a texture that doesn't have a miptree
694 * (has a border, width/height 0, etc.)
696 _mesa_reference_renderbuffer(&att
->Renderbuffer
, NULL
);
697 _swrast_render_texture(ctx
, fb
, att
);
701 irb
= intel_wrap_texture(ctx
, image
);
703 /* bind the wrapper to the attachment point */
704 _mesa_reference_renderbuffer(&att
->Renderbuffer
, &irb
->Base
);
707 /* fallback to software rendering */
708 _swrast_render_texture(ctx
, fb
, att
);
713 if (!intel_update_wrapper(ctx
, irb
, image
)) {
714 _mesa_reference_renderbuffer(&att
->Renderbuffer
, NULL
);
715 _swrast_render_texture(ctx
, fb
, att
);
719 DBG("Begin render texture tid %lx tex=%u w=%d h=%d refcount=%d\n",
721 att
->Texture
->Name
, image
->Width
, image
->Height
,
724 intel_renderbuffer_set_draw_offset(irb
, intel_image
, att
->Zoffset
);
725 intel_image
->used_as_render_target
= GL_TRUE
;
728 if (need_tile_offset_workaround(brw_context(ctx
), irb
)) {
729 /* Original gen4 hardware couldn't draw to a non-tile-aligned
730 * destination in a miptree unless you actually setup your
731 * renderbuffer as a miptree and used the fragile
732 * lod/array_index/etc. controls to select the image. So,
733 * instead, we just make a new single-level miptree and render
736 struct intel_context
*intel
= intel_context(ctx
);
737 struct intel_mipmap_tree
*old_mt
= intel_image
->mt
;
738 struct intel_mipmap_tree
*new_mt
;
740 new_mt
= intel_miptree_create(intel
, image
->TexObject
->Target
,
741 intel_image
->base
.Base
.TexFormat
,
742 intel_image
->base
.Base
.Level
,
743 intel_image
->base
.Base
.Level
,
744 intel_image
->base
.Base
.Width
,
745 intel_image
->base
.Base
.Height
,
746 intel_image
->base
.Base
.Depth
,
749 intel_miptree_image_copy(intel
,
751 intel_image
->base
.Base
.Face
,
752 intel_image
->base
.Base
.Level
,
755 intel_miptree_release(intel
, &intel_image
->mt
);
756 intel_image
->mt
= new_mt
;
757 intel_renderbuffer_set_draw_offset(irb
, intel_image
, att
->Zoffset
);
759 intel_region_reference(&irb
->region
, intel_image
->mt
->region
);
762 /* update drawing region, etc */
763 intel_draw_buffer(ctx
);
768 * Called by Mesa when rendering to a texture is done.
771 intel_finish_render_texture(struct gl_context
* ctx
,
772 struct gl_renderbuffer_attachment
*att
)
774 struct intel_context
*intel
= intel_context(ctx
);
775 struct gl_texture_object
*tex_obj
= att
->Texture
;
776 struct gl_texture_image
*image
=
777 tex_obj
->Image
[att
->CubeMapFace
][att
->TextureLevel
];
778 struct intel_texture_image
*intel_image
= intel_texture_image(image
);
780 DBG("Finish render texture tid %lx tex=%u\n",
781 _glthread_GetID(), att
->Texture
->Name
);
783 /* Flag that this image may now be validated into the object's miptree. */
785 intel_image
->used_as_render_target
= GL_FALSE
;
787 /* Since we've (probably) rendered to the texture and will (likely) use
788 * it in the texture domain later on in this batchbuffer, flush the
789 * batch. Once again, we wish for a domain tracker in libdrm to cover
790 * usage inside of a batchbuffer like GEM does in the kernel.
792 intel_batchbuffer_emit_mi_flush(intel
);
796 * Do additional "completeness" testing of a framebuffer object.
799 intel_validate_framebuffer(struct gl_context
*ctx
, struct gl_framebuffer
*fb
)
801 struct intel_context
*intel
= intel_context(ctx
);
802 const struct intel_renderbuffer
*depthRb
=
803 intel_get_renderbuffer(fb
, BUFFER_DEPTH
);
804 const struct intel_renderbuffer
*stencilRb
=
805 intel_get_renderbuffer(fb
, BUFFER_STENCIL
);
809 * The depth and stencil renderbuffers are the same renderbuffer or wrap
812 if (depthRb
&& stencilRb
) {
813 bool depth_stencil_are_same
;
814 if (depthRb
== stencilRb
)
815 depth_stencil_are_same
= true;
816 else if ((fb
->Attachment
[BUFFER_DEPTH
].Type
== GL_TEXTURE
) &&
817 (fb
->Attachment
[BUFFER_STENCIL
].Type
== GL_TEXTURE
) &&
818 (fb
->Attachment
[BUFFER_DEPTH
].Texture
->Name
==
819 fb
->Attachment
[BUFFER_STENCIL
].Texture
->Name
))
820 depth_stencil_are_same
= true;
822 depth_stencil_are_same
= false;
824 if (!intel
->has_separate_stencil
&& !depth_stencil_are_same
) {
825 fb
->_Status
= GL_FRAMEBUFFER_UNSUPPORTED_EXT
;
829 for (i
= 0; i
< Elements(fb
->Attachment
); i
++) {
830 struct gl_renderbuffer
*rb
;
831 struct intel_renderbuffer
*irb
;
833 if (fb
->Attachment
[i
].Type
== GL_NONE
)
836 /* A supported attachment will have a Renderbuffer set either
837 * from being a Renderbuffer or being a texture that got the
838 * intel_wrap_texture() treatment.
840 rb
= fb
->Attachment
[i
].Renderbuffer
;
842 DBG("attachment without renderbuffer\n");
843 fb
->_Status
= GL_FRAMEBUFFER_UNSUPPORTED_EXT
;
847 irb
= intel_renderbuffer(rb
);
849 DBG("software rendering renderbuffer\n");
850 fb
->_Status
= GL_FRAMEBUFFER_UNSUPPORTED_EXT
;
854 if (!intel_span_supports_format(irb
->Base
.Format
) ||
855 !intel
->vtbl
.render_target_supported(irb
->Base
.Format
)) {
856 DBG("Unsupported texture/renderbuffer format attached: %s\n",
857 _mesa_get_format_name(irb
->Base
.Format
));
858 fb
->_Status
= GL_FRAMEBUFFER_UNSUPPORTED_EXT
;
864 * Try to do a glBlitFramebuffer using glCopyTexSubImage2D
865 * We can do this when the dst renderbuffer is actually a texture and
866 * there is no scaling, mirroring or scissoring.
868 * \return new buffer mask indicating the buffers left to blit using the
872 intel_blit_framebuffer_copy_tex_sub_image(struct gl_context
*ctx
,
873 GLint srcX0
, GLint srcY0
,
874 GLint srcX1
, GLint srcY1
,
875 GLint dstX0
, GLint dstY0
,
876 GLint dstX1
, GLint dstY1
,
877 GLbitfield mask
, GLenum filter
)
879 if (mask
& GL_COLOR_BUFFER_BIT
) {
880 const struct gl_framebuffer
*drawFb
= ctx
->DrawBuffer
;
881 const struct gl_framebuffer
*readFb
= ctx
->ReadBuffer
;
882 const struct gl_renderbuffer_attachment
*drawAtt
=
883 &drawFb
->Attachment
[drawFb
->_ColorDrawBufferIndexes
[0]];
885 /* If the source and destination are the same size with no
886 mirroring, the rectangles are within the size of the
887 texture and there is no scissor then we can use
888 glCopyTexSubimage2D to implement the blit. This will end
889 up as a fast hardware blit on some drivers */
890 if (drawAtt
&& drawAtt
->Texture
&&
891 srcX0
- srcX1
== dstX0
- dstX1
&&
892 srcY0
- srcY1
== dstY0
- dstY1
&&
895 srcX0
>= 0 && srcX1
<= readFb
->Width
&&
896 srcY0
>= 0 && srcY1
<= readFb
->Height
&&
897 dstX0
>= 0 && dstX1
<= drawFb
->Width
&&
898 dstY0
>= 0 && dstY1
<= drawFb
->Height
&&
899 !ctx
->Scissor
.Enabled
) {
900 const struct gl_texture_object
*texObj
= drawAtt
->Texture
;
901 const GLuint dstLevel
= drawAtt
->TextureLevel
;
902 const GLenum target
= texObj
->Target
;
904 struct gl_texture_image
*texImage
=
905 _mesa_select_tex_image(ctx
, texObj
, target
, dstLevel
);
907 if (intel_copy_texsubimage(intel_context(ctx
),
908 intel_texture_image(texImage
),
911 srcX1
- srcX0
, /* width */
913 mask
&= ~GL_COLOR_BUFFER_BIT
;
921 intel_blit_framebuffer(struct gl_context
*ctx
,
922 GLint srcX0
, GLint srcY0
, GLint srcX1
, GLint srcY1
,
923 GLint dstX0
, GLint dstY0
, GLint dstX1
, GLint dstY1
,
924 GLbitfield mask
, GLenum filter
)
926 /* Try faster, glCopyTexSubImage2D approach first which uses the BLT. */
927 mask
= intel_blit_framebuffer_copy_tex_sub_image(ctx
,
928 srcX0
, srcY0
, srcX1
, srcY1
,
929 dstX0
, dstY0
, dstX1
, dstY1
,
934 _mesa_meta_BlitFramebuffer(ctx
,
935 srcX0
, srcY0
, srcX1
, srcY1
,
936 dstX0
, dstY0
, dstX1
, dstY1
,
941 * Do one-time context initializations related to GL_EXT_framebuffer_object.
942 * Hook in device driver functions.
945 intel_fbo_init(struct intel_context
*intel
)
947 intel
->ctx
.Driver
.NewFramebuffer
= intel_new_framebuffer
;
948 intel
->ctx
.Driver
.NewRenderbuffer
= intel_new_renderbuffer
;
949 intel
->ctx
.Driver
.BindFramebuffer
= intel_bind_framebuffer
;
950 intel
->ctx
.Driver
.FramebufferRenderbuffer
= intel_framebuffer_renderbuffer
;
951 intel
->ctx
.Driver
.RenderTexture
= intel_render_texture
;
952 intel
->ctx
.Driver
.FinishRenderTexture
= intel_finish_render_texture
;
953 intel
->ctx
.Driver
.ResizeBuffers
= intel_resize_buffers
;
954 intel
->ctx
.Driver
.ValidateFramebuffer
= intel_validate_framebuffer
;
955 intel
->ctx
.Driver
.BlitFramebuffer
= intel_blit_framebuffer
;
957 #if FEATURE_OES_EGL_image
958 intel
->ctx
.Driver
.EGLImageTargetRenderbufferStorage
=
959 intel_image_target_renderbuffer_storage
;