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