src/mesa/drivers/dri/intel/intel_fbo.c

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