intel_fbo.c revision c0a61c8442af3cfa810098d34bf6a21d11a5d720 
1/**************************************************************************
2 *
3 * Copyright 2006 Tungsten Graphics, Inc., Cedar Park, Texas.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28
29#include "main/imports.h"
30#include "main/macros.h"
31#include "main/mtypes.h"
32#include "main/fbobject.h"
33#include "main/framebuffer.h"
34#include "main/renderbuffer.h"
35#include "main/context.h"
36#include "main/texformat.h"
37#include "main/texrender.h"
38#include "drivers/common/meta.h"
39
40#include "intel_context.h"
41#include "intel_buffers.h"
42#include "intel_fbo.h"
43#include "intel_mipmap_tree.h"
44#include "intel_regions.h"
45
46
47#define FILE_DEBUG_FLAG DEBUG_FBO
48
49
50/**
51 * Create a new framebuffer object.
52 */
53static struct gl_framebuffer *
54intel_new_framebuffer(GLcontext * ctx, GLuint name)
55{
56   /* Only drawable state in intel_framebuffer at this time, just use Mesa's
57    * class
58    */
59   return _mesa_new_framebuffer(ctx, name);
60}
61
62
63/** Called by gl_renderbuffer::Delete() */
64static void
65intel_delete_renderbuffer(struct gl_renderbuffer *rb)
66{
67   GET_CURRENT_CONTEXT(ctx);
68   struct intel_context *intel = intel_context(ctx);
69   struct intel_renderbuffer *irb = intel_renderbuffer(rb);
70
71   ASSERT(irb);
72
73   if (irb->span_cache != NULL)
74      _mesa_free(irb->span_cache);
75
76   if (intel && irb->region) {
77      intel_region_release(&irb->region);
78   }
79
80   _mesa_free(irb);
81}
82
83
84/**
85 * Return a pointer to a specific pixel in a renderbuffer.
86 */
87static void *
88intel_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
89                  GLint x, GLint y)
90{
91   /* By returning NULL we force all software rendering to go through
92    * the span routines.
93    */
94   return NULL;
95}
96
97
98/**
99 * Called via glRenderbufferStorageEXT() to set the format and allocate
100 * storage for a user-created renderbuffer.
101 */
102static GLboolean
103intel_alloc_renderbuffer_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
104                                 GLenum internalFormat,
105                                 GLuint width, GLuint height)
106{
107   struct intel_context *intel = intel_context(ctx);
108   struct intel_renderbuffer *irb = intel_renderbuffer(rb);
109   GLboolean softwareBuffer = GL_FALSE;
110   int cpp;
111
112   ASSERT(rb->Name != 0);
113
114   switch (internalFormat) {
115   case GL_R3_G3_B2:
116   case GL_RGB4:
117   case GL_RGB5:
118      rb->_ActualFormat = GL_RGB5;
119      rb->DataType = GL_UNSIGNED_BYTE;
120      rb->RedBits = 5;
121      rb->GreenBits = 6;
122      rb->BlueBits = 5;
123      irb->texformat = &_mesa_texformat_rgb565;
124      cpp = 2;
125      break;
126   case GL_RGB:
127   case GL_RGB8:
128   case GL_RGB10:
129   case GL_RGB12:
130   case GL_RGB16:
131      rb->_ActualFormat = GL_RGB8;
132      rb->DataType = GL_UNSIGNED_BYTE;
133      rb->RedBits = 8;
134      rb->GreenBits = 8;
135      rb->BlueBits = 8;
136      rb->AlphaBits = 0;
137      irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */
138      cpp = 4;
139      break;
140   case GL_RGBA:
141   case GL_RGBA2:
142   case GL_RGBA4:
143   case GL_RGB5_A1:
144   case GL_RGBA8:
145   case GL_RGB10_A2:
146   case GL_RGBA12:
147   case GL_RGBA16:
148      rb->_ActualFormat = GL_RGBA8;
149      rb->DataType = GL_UNSIGNED_BYTE;
150      rb->RedBits = 8;
151      rb->GreenBits = 8;
152      rb->BlueBits = 8;
153      rb->AlphaBits = 8;
154      irb->texformat = &_mesa_texformat_argb8888;
155      cpp = 4;
156      break;
157   case GL_STENCIL_INDEX:
158   case GL_STENCIL_INDEX1_EXT:
159   case GL_STENCIL_INDEX4_EXT:
160   case GL_STENCIL_INDEX8_EXT:
161   case GL_STENCIL_INDEX16_EXT:
162      /* alloc a depth+stencil buffer */
163      rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
164      rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
165      rb->StencilBits = 8;
166      cpp = 4;
167      irb->texformat = &_mesa_texformat_s8_z24;
168      break;
169   case GL_DEPTH_COMPONENT16:
170      rb->_ActualFormat = GL_DEPTH_COMPONENT16;
171      rb->DataType = GL_UNSIGNED_SHORT;
172      rb->DepthBits = 16;
173      cpp = 2;
174      irb->texformat = &_mesa_texformat_z16;
175      break;
176   case GL_DEPTH_COMPONENT:
177   case GL_DEPTH_COMPONENT24:
178   case GL_DEPTH_COMPONENT32:
179      rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
180      rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
181      rb->DepthBits = 24;
182      cpp = 4;
183      irb->texformat = &_mesa_texformat_s8_z24;
184      break;
185   case GL_DEPTH_STENCIL_EXT:
186   case GL_DEPTH24_STENCIL8_EXT:
187      rb->_ActualFormat = GL_DEPTH24_STENCIL8_EXT;
188      rb->DataType = GL_UNSIGNED_INT_24_8_EXT;
189      rb->DepthBits = 24;
190      rb->StencilBits = 8;
191      cpp = 4;
192      irb->texformat = &_mesa_texformat_s8_z24;
193      break;
194   default:
195      _mesa_problem(ctx,
196                    "Unexpected format in intel_alloc_renderbuffer_storage");
197      return GL_FALSE;
198   }
199
200   intelFlush(ctx);
201
202   /* free old region */
203   if (irb->region) {
204      intel_region_release(&irb->region);
205   }
206
207   /* allocate new memory region/renderbuffer */
208   if (softwareBuffer) {
209      return _mesa_soft_renderbuffer_storage(ctx, rb, internalFormat,
210                                             width, height);
211   }
212   else {
213      /* Choose a pitch to match hardware requirements:
214       */
215      GLuint pitch = ((cpp * width + 63) & ~63) / cpp;
216
217      /* alloc hardware renderbuffer */
218      DBG("Allocating %d x %d Intel RBO (pitch %d)\n", width,
219	  height, pitch);
220
221      irb->region = intel_region_alloc(intel, I915_TILING_NONE,
222				       cpp, width, height, pitch,
223				       GL_TRUE);
224      if (!irb->region)
225         return GL_FALSE;       /* out of memory? */
226
227      ASSERT(irb->region->buffer);
228
229      rb->Width = width;
230      rb->Height = height;
231
232      return GL_TRUE;
233   }
234}
235
236
237/**
238 * Called for each hardware renderbuffer when a _window_ is resized.
239 * Just update fields.
240 * Not used for user-created renderbuffers!
241 */
242static GLboolean
243intel_alloc_window_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
244                           GLenum internalFormat, GLuint width, GLuint height)
245{
246   ASSERT(rb->Name == 0);
247   rb->Width = width;
248   rb->Height = height;
249   rb->_ActualFormat = internalFormat;
250
251   return GL_TRUE;
252}
253
254
255static void
256intel_resize_buffers(GLcontext *ctx, struct gl_framebuffer *fb,
257		     GLuint width, GLuint height)
258{
259   struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)fb;
260   int i;
261
262   _mesa_resize_framebuffer(ctx, fb, width, height);
263
264   fb->Initialized = GL_TRUE; /* XXX remove someday */
265
266   if (fb->Name != 0) {
267      return;
268   }
269
270   /* Make sure all window system renderbuffers are up to date */
271   for (i = 0; i < 2; i++) {
272      struct gl_renderbuffer *rb = &intel_fb->color_rb[i]->Base;
273
274      /* only resize if size is changing */
275      if (rb && (rb->Width != width || rb->Height != height)) {
276	 rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height);
277      }
278   }
279}
280
281
282/** Dummy function for gl_renderbuffer::AllocStorage() */
283static GLboolean
284intel_nop_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
285                        GLenum internalFormat, GLuint width, GLuint height)
286{
287   _mesa_problem(ctx, "intel_op_alloc_storage should never be called.");
288   return GL_FALSE;
289}
290
291
292void
293intel_renderbuffer_set_region(struct intel_renderbuffer *rb,
294			      struct intel_region *region)
295{
296   struct intel_region *old;
297
298   old = rb->region;
299   rb->region = NULL;
300   intel_region_reference(&rb->region, region);
301   intel_region_release(&old);
302}
303
304
305/**
306 * Create a new intel_renderbuffer which corresponds to an on-screen window,
307 * not a user-created renderbuffer.
308 */
309struct intel_renderbuffer *
310intel_create_renderbuffer(GLenum intFormat)
311{
312   GET_CURRENT_CONTEXT(ctx);
313
314   struct intel_renderbuffer *irb;
315   const GLuint name = 0;
316
317   irb = CALLOC_STRUCT(intel_renderbuffer);
318   if (!irb) {
319      _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
320      return NULL;
321   }
322
323   _mesa_init_renderbuffer(&irb->Base, name);
324   irb->Base.ClassID = INTEL_RB_CLASS;
325
326   switch (intFormat) {
327   case GL_RGB5:
328      irb->Base._ActualFormat = GL_RGB5;
329      irb->Base._BaseFormat = GL_RGBA;
330      irb->Base.RedBits = 5;
331      irb->Base.GreenBits = 6;
332      irb->Base.BlueBits = 5;
333      irb->Base.DataType = GL_UNSIGNED_BYTE;
334      irb->texformat = &_mesa_texformat_rgb565;
335      break;
336   case GL_RGB8:
337      irb->Base._ActualFormat = GL_RGB8;
338      irb->Base._BaseFormat = GL_RGB;
339      irb->Base.RedBits = 8;
340      irb->Base.GreenBits = 8;
341      irb->Base.BlueBits = 8;
342      irb->Base.AlphaBits = 0;
343      irb->Base.DataType = GL_UNSIGNED_BYTE;
344      irb->texformat = &_mesa_texformat_argb8888; /* XXX: Need xrgb8888 */
345      break;
346   case GL_RGBA8:
347      irb->Base._ActualFormat = GL_RGBA8;
348      irb->Base._BaseFormat = GL_RGBA;
349      irb->Base.RedBits = 8;
350      irb->Base.GreenBits = 8;
351      irb->Base.BlueBits = 8;
352      irb->Base.AlphaBits = 8;
353      irb->Base.DataType = GL_UNSIGNED_BYTE;
354      irb->texformat = &_mesa_texformat_argb8888;
355      break;
356   case GL_STENCIL_INDEX8_EXT:
357      irb->Base._ActualFormat = GL_STENCIL_INDEX8_EXT;
358      irb->Base._BaseFormat = GL_STENCIL_INDEX;
359      irb->Base.StencilBits = 8;
360      irb->Base.DataType = GL_UNSIGNED_BYTE;
361      irb->texformat = &_mesa_texformat_s8_z24;
362      break;
363   case GL_DEPTH_COMPONENT16:
364      irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
365      irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
366      irb->Base.DepthBits = 16;
367      irb->Base.DataType = GL_UNSIGNED_SHORT;
368      irb->texformat = &_mesa_texformat_z16;
369      break;
370   case GL_DEPTH_COMPONENT24:
371      irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
372      irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
373      irb->Base.DepthBits = 24;
374      irb->Base.DataType = GL_UNSIGNED_INT;
375      irb->texformat = &_mesa_texformat_s8_z24;
376      break;
377   case GL_DEPTH24_STENCIL8_EXT:
378      irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
379      irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
380      irb->Base.DepthBits = 24;
381      irb->Base.StencilBits = 8;
382      irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
383      irb->texformat = &_mesa_texformat_s8_z24;
384      break;
385   default:
386      _mesa_problem(NULL,
387                    "Unexpected intFormat in intel_create_renderbuffer");
388      _mesa_free(irb);
389      return NULL;
390   }
391
392   irb->Base.InternalFormat = intFormat;
393
394   /* intel-specific methods */
395   irb->Base.Delete = intel_delete_renderbuffer;
396   irb->Base.AllocStorage = intel_alloc_window_storage;
397   irb->Base.GetPointer = intel_get_pointer;
398
399   return irb;
400}
401
402
403/**
404 * Create a new renderbuffer object.
405 * Typically called via glBindRenderbufferEXT().
406 */
407static struct gl_renderbuffer *
408intel_new_renderbuffer(GLcontext * ctx, GLuint name)
409{
410   /*struct intel_context *intel = intel_context(ctx); */
411   struct intel_renderbuffer *irb;
412
413   irb = CALLOC_STRUCT(intel_renderbuffer);
414   if (!irb) {
415      _mesa_error(ctx, GL_OUT_OF_MEMORY, "creating renderbuffer");
416      return NULL;
417   }
418
419   _mesa_init_renderbuffer(&irb->Base, name);
420   irb->Base.ClassID = INTEL_RB_CLASS;
421
422   /* intel-specific methods */
423   irb->Base.Delete = intel_delete_renderbuffer;
424   irb->Base.AllocStorage = intel_alloc_renderbuffer_storage;
425   irb->Base.GetPointer = intel_get_pointer;
426   /* span routines set in alloc_storage function */
427
428   return &irb->Base;
429}
430
431
432/**
433 * Called via glBindFramebufferEXT().
434 */
435static void
436intel_bind_framebuffer(GLcontext * ctx, GLenum target,
437                       struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
438{
439   if (target == GL_FRAMEBUFFER_EXT || target == GL_DRAW_FRAMEBUFFER_EXT) {
440      intel_draw_buffer(ctx, fb);
441   }
442   else {
443      /* don't need to do anything if target == GL_READ_FRAMEBUFFER_EXT */
444   }
445}
446
447
448/**
449 * Called via glFramebufferRenderbufferEXT().
450 */
451static void
452intel_framebuffer_renderbuffer(GLcontext * ctx,
453                               struct gl_framebuffer *fb,
454                               GLenum attachment, struct gl_renderbuffer *rb)
455{
456   DBG("Intel FramebufferRenderbuffer %u %u\n", fb->Name, rb ? rb->Name : 0);
457
458   intelFlush(ctx);
459
460   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
461   intel_draw_buffer(ctx, fb);
462}
463
464
465static GLboolean
466intel_update_wrapper(GLcontext *ctx, struct intel_renderbuffer *irb,
467		     struct gl_texture_image *texImage)
468{
469   irb->texformat = texImage->TexFormat;
470
471   if (texImage->TexFormat == &_mesa_texformat_argb8888) {
472      irb->Base._ActualFormat = GL_RGBA8;
473      irb->Base._BaseFormat = GL_RGBA;
474      irb->Base.DataType = GL_UNSIGNED_BYTE;
475      DBG("Render to RGBA8 texture OK\n");
476   }
477   else if (texImage->TexFormat == &_mesa_texformat_rgb565) {
478      irb->Base._ActualFormat = GL_RGB5;
479      irb->Base._BaseFormat = GL_RGB;
480      irb->Base.DataType = GL_UNSIGNED_BYTE;
481      DBG("Render to RGB5 texture OK\n");
482   }
483   else if (texImage->TexFormat == &_mesa_texformat_argb1555) {
484      irb->Base._ActualFormat = GL_RGB5_A1;
485      irb->Base._BaseFormat = GL_RGBA;
486      irb->Base.DataType = GL_UNSIGNED_BYTE;
487      DBG("Render to ARGB1555 texture OK\n");
488   }
489   else if (texImage->TexFormat == &_mesa_texformat_argb4444) {
490      irb->Base._ActualFormat = GL_RGBA4;
491      irb->Base._BaseFormat = GL_RGBA;
492      irb->Base.DataType = GL_UNSIGNED_BYTE;
493      DBG("Render to ARGB4444 texture OK\n");
494   }
495   else if (texImage->TexFormat == &_mesa_texformat_z16) {
496      irb->Base._ActualFormat = GL_DEPTH_COMPONENT16;
497      irb->Base._BaseFormat = GL_DEPTH_COMPONENT;
498      irb->Base.DataType = GL_UNSIGNED_SHORT;
499      DBG("Render to DEPTH16 texture OK\n");
500   }
501   else if (texImage->TexFormat == &_mesa_texformat_s8_z24) {
502      irb->Base._ActualFormat = GL_DEPTH24_STENCIL8_EXT;
503      irb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
504      irb->Base.DataType = GL_UNSIGNED_INT_24_8_EXT;
505      DBG("Render to DEPTH_STENCIL texture OK\n");
506   }
507   else {
508      DBG("Render to texture BAD FORMAT %d\n",
509	  texImage->TexFormat->MesaFormat);
510      return GL_FALSE;
511   }
512
513   irb->Base.InternalFormat = irb->Base._ActualFormat;
514   irb->Base.Width = texImage->Width;
515   irb->Base.Height = texImage->Height;
516   irb->Base.RedBits = texImage->TexFormat->RedBits;
517   irb->Base.GreenBits = texImage->TexFormat->GreenBits;
518   irb->Base.BlueBits = texImage->TexFormat->BlueBits;
519   irb->Base.AlphaBits = texImage->TexFormat->AlphaBits;
520   irb->Base.DepthBits = texImage->TexFormat->DepthBits;
521   irb->Base.StencilBits = texImage->TexFormat->StencilBits;
522
523   irb->Base.Delete = intel_delete_renderbuffer;
524   irb->Base.AllocStorage = intel_nop_alloc_storage;
525
526   return GL_TRUE;
527}
528
529
530/**
531 * When glFramebufferTexture[123]D is called this function sets up the
532 * gl_renderbuffer wrapper around the texture image.
533 * This will have the region info needed for hardware rendering.
534 */
535static struct intel_renderbuffer *
536intel_wrap_texture(GLcontext * ctx, struct gl_texture_image *texImage)
537{
538   const GLuint name = ~0;   /* not significant, but distinct for debugging */
539   struct intel_renderbuffer *irb;
540
541   /* make an intel_renderbuffer to wrap the texture image */
542   irb = CALLOC_STRUCT(intel_renderbuffer);
543   if (!irb) {
544      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture");
545      return NULL;
546   }
547
548   _mesa_init_renderbuffer(&irb->Base, name);
549   irb->Base.ClassID = INTEL_RB_CLASS;
550
551   if (!intel_update_wrapper(ctx, irb, texImage)) {
552      _mesa_free(irb);
553      return NULL;
554   }
555
556   return irb;
557}
558
559
560/**
561 * Called by glFramebufferTexture[123]DEXT() (and other places) to
562 * prepare for rendering into texture memory.  This might be called
563 * many times to choose different texture levels, cube faces, etc
564 * before intel_finish_render_texture() is ever called.
565 */
566static void
567intel_render_texture(GLcontext * ctx,
568                     struct gl_framebuffer *fb,
569                     struct gl_renderbuffer_attachment *att)
570{
571   struct gl_texture_image *newImage
572      = att->Texture->Image[att->CubeMapFace][att->TextureLevel];
573   struct intel_renderbuffer *irb = intel_renderbuffer(att->Renderbuffer);
574   struct intel_texture_image *intel_image;
575   GLuint dst_x, dst_y;
576
577   (void) fb;
578
579   ASSERT(newImage);
580
581   intel_image = intel_texture_image(newImage);
582   if (!intel_image->mt) {
583      /* Fallback on drawing to a texture that doesn't have a miptree
584       * (has a border, width/height 0, etc.)
585       */
586      _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
587      _mesa_render_texture(ctx, fb, att);
588      return;
589   }
590   else if (!irb) {
591      irb = intel_wrap_texture(ctx, newImage);
592      if (irb) {
593         /* bind the wrapper to the attachment point */
594         _mesa_reference_renderbuffer(&att->Renderbuffer, &irb->Base);
595      }
596      else {
597         /* fallback to software rendering */
598         _mesa_render_texture(ctx, fb, att);
599         return;
600      }
601   }
602
603   if (!intel_update_wrapper(ctx, irb, newImage)) {
604       _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
605       _mesa_render_texture(ctx, fb, att);
606       return;
607   }
608
609   DBG("Begin render texture tid %x tex=%u w=%d h=%d refcount=%d\n",
610       _glthread_GetID(),
611       att->Texture->Name, newImage->Width, newImage->Height,
612       irb->Base.RefCount);
613
614   /* point the renderbufer's region to the texture image region */
615   if (irb->region != intel_image->mt->region) {
616      if (irb->region)
617	 intel_region_release(&irb->region);
618      intel_region_reference(&irb->region, intel_image->mt->region);
619   }
620
621   /* compute offset of the particular 2D image within the texture region */
622   intel_miptree_get_image_offset(intel_image->mt,
623				  att->TextureLevel,
624				  att->CubeMapFace,
625				  att->Zoffset,
626				  &dst_x, &dst_y);
627
628   intel_image->mt->region->draw_offset = (dst_y * intel_image->mt->pitch +
629					   dst_x) * intel_image->mt->cpp;
630   intel_image->mt->region->draw_x = dst_x;
631   intel_image->mt->region->draw_y = dst_y;
632
633   /* update drawing region, etc */
634   intel_draw_buffer(ctx, fb);
635}
636
637
638/**
639 * Called by Mesa when rendering to a texture is done.
640 */
641static void
642intel_finish_render_texture(GLcontext * ctx,
643                            struct gl_renderbuffer_attachment *att)
644{
645   /* no-op
646    * Previously we released the renderbuffer's intel_region but
647    * that's not necessary and actually caused problems when trying
648    * to do a glRead/CopyPixels from the renderbuffer later.
649    * The region will be released later if the texture is replaced
650    * or the renderbuffer deleted.
651    *
652    * The intention of this driver hook is more of a "done rendering
653    * to texture, please re-twiddle/etc if necessary".
654    */
655}
656
657
658/**
659 * Do additional "completeness" testing of a framebuffer object.
660 */
661static void
662intel_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
663{
664   const struct intel_renderbuffer *depthRb =
665      intel_get_renderbuffer(fb, BUFFER_DEPTH);
666   const struct intel_renderbuffer *stencilRb =
667      intel_get_renderbuffer(fb, BUFFER_STENCIL);
668   int i;
669
670   if (stencilRb && stencilRb != depthRb) {
671      /* we only support combined depth/stencil buffers, not separate
672       * stencil buffers.
673       */
674      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
675   }
676
677   for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
678      struct gl_renderbuffer *rb = ctx->DrawBuffer->_ColorDrawBuffers[i];
679      struct intel_renderbuffer *irb = intel_renderbuffer(rb);
680
681      if (rb == NULL)
682	 continue;
683
684      if (irb == NULL) {
685	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
686	 continue;
687      }
688
689      switch (irb->texformat->MesaFormat) {
690      case MESA_FORMAT_ARGB8888:
691      case MESA_FORMAT_RGB565:
692      case MESA_FORMAT_ARGB1555:
693      case MESA_FORMAT_ARGB4444:
694	 break;
695      default:
696	 fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
697      }
698   }
699}
700
701
702/**
703 * Do one-time context initializations related to GL_EXT_framebuffer_object.
704 * Hook in device driver functions.
705 */
706void
707intel_fbo_init(struct intel_context *intel)
708{
709   intel->ctx.Driver.NewFramebuffer = intel_new_framebuffer;
710   intel->ctx.Driver.NewRenderbuffer = intel_new_renderbuffer;
711   intel->ctx.Driver.BindFramebuffer = intel_bind_framebuffer;
712   intel->ctx.Driver.FramebufferRenderbuffer = intel_framebuffer_renderbuffer;
713   intel->ctx.Driver.RenderTexture = intel_render_texture;
714   intel->ctx.Driver.FinishRenderTexture = intel_finish_render_texture;
715   intel->ctx.Driver.ResizeBuffers = intel_resize_buffers;
716   intel->ctx.Driver.ValidateFramebuffer = intel_validate_framebuffer;
717   intel->ctx.Driver.BlitFramebuffer = _mesa_meta_blit_framebuffer;
718}
719