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