src/mesa/swrast/s_renderbuffer.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  6.5
   4  *
   5  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /**
  27  * Functions for allocating/managing software-based renderbuffers.
  28  * Also, routines for reading/writing software-based renderbuffer data as
  29  * ubytes, ushorts, uints, etc.
  30  */
  31
  32
  33 #include "main/glheader.h"
  34 #include "main/imports.h"
  35 #include "main/context.h"
  36 #include "main/fbobject.h"
  37 #include "main/formats.h"
  38 #include "main/mtypes.h"
  39 #include "main/renderbuffer.h"
  40 #include "swrast/s_context.h"
  41 #include "swrast/s_renderbuffer.h"
  42
  43
  44 /**
  45  * This is a software fallback for the gl_renderbuffer->AllocStorage
  46  * function.
  47  * Device drivers will typically override this function for the buffers
  48  * which it manages (typically color buffers, Z and stencil).
  49  * Other buffers (like software accumulation and aux buffers) which the driver
  50  * doesn't manage can be handled with this function.
  51  *
  52  * This one multi-purpose function can allocate stencil, depth, accum, color
  53  * or color-index buffers!
  54  */
  55 static GLboolean
  56 soft_renderbuffer_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
  57                           GLenum internalFormat,
  58                           GLuint width, GLuint height)
  59 {
  60    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
  61    GLuint bpp;
  62
  63    switch (internalFormat) {
  64    case GL_RGB:
  65    case GL_R3_G3_B2:
  66    case GL_RGB4:
  67    case GL_RGB5:
  68    case GL_RGB8:
  69    case GL_RGB10:
  70    case GL_RGB12:
  71    case GL_RGB16:
  72       rb->Format = MESA_FORMAT_RGB888;
  73       break;
  74    case GL_RGBA:
  75    case GL_RGBA2:
  76    case GL_RGBA4:
  77    case GL_RGB5_A1:
  78    case GL_RGBA8:
  79 #if 1
  80    case GL_RGB10_A2:
  81    case GL_RGBA12:
  82 #endif
  83       if (_mesa_little_endian())
  84          rb->Format = MESA_FORMAT_RGBA8888_REV;
  85       else
  86          rb->Format = MESA_FORMAT_RGBA8888;
  87       break;
  88    case GL_RGBA16:
  89    case GL_RGBA16_SNORM:
  90       /* for accum buffer */
  91       rb->Format = MESA_FORMAT_SIGNED_RGBA_16;
  92       break;
  93    case GL_STENCIL_INDEX:
  94    case GL_STENCIL_INDEX1_EXT:
  95    case GL_STENCIL_INDEX4_EXT:
  96    case GL_STENCIL_INDEX8_EXT:
  97    case GL_STENCIL_INDEX16_EXT:
  98       rb->Format = MESA_FORMAT_S8;
  99       break;
 100    case GL_DEPTH_COMPONENT:
 101    case GL_DEPTH_COMPONENT16:
 102       rb->Format = MESA_FORMAT_Z16;
 103       break;
 104    case GL_DEPTH_COMPONENT24:
 105       rb->Format = MESA_FORMAT_X8_Z24;
 106       break;
 107    case GL_DEPTH_COMPONENT32:
 108       rb->Format = MESA_FORMAT_Z32;
 109       break;
 110    case GL_DEPTH_STENCIL_EXT:
 111    case GL_DEPTH24_STENCIL8_EXT:
 112       rb->Format = MESA_FORMAT_Z24_S8;
 113       break;
 114    default:
 115       /* unsupported format */
 116       return GL_FALSE;
 117    }
 118
 119    bpp = _mesa_get_format_bytes(rb->Format);
 120
 121    /* free old buffer storage */
 122    if (srb->Buffer) {
 123       free(srb->Buffer);
 124       srb->Buffer = NULL;
 125    }
 126
 127    srb->RowStride = width * bpp;
 128
 129    if (width > 0 && height > 0) {
 130       /* allocate new buffer storage */
 131       srb->Buffer = malloc(srb->RowStride * height);
 132
 133       if (srb->Buffer == NULL) {
 134          rb->Width = 0;
 135          rb->Height = 0;
 136          _mesa_error(ctx, GL_OUT_OF_MEMORY,
 137                      "software renderbuffer allocation (%d x %d x %d)",
 138                      width, height, bpp);
 139          return GL_FALSE;
 140       }
 141    }
 142
 143    rb->Width = width;
 144    rb->Height = height;
 145    rb->_BaseFormat = _mesa_base_fbo_format(ctx, internalFormat);
 146
 147    if (rb->Name == 0 &&
 148        internalFormat == GL_RGBA16_SNORM &&
 149        rb->_BaseFormat == 0) {
 150       /* NOTE: This is a special case just for accumulation buffers.
 151        * This is a very limited use case- there's no snorm texturing or
 152        * rendering going on.
 153        */
 154       rb->_BaseFormat = GL_RGBA;
 155    }
 156    else {
 157       /* the internalFormat should have been error checked long ago */
 158       ASSERT(rb->_BaseFormat);
 159    }
 160
 161    return GL_TRUE;
 162 }
 163
 164
 165 /**
 166  * Called via gl_renderbuffer::Delete()
 167  */
 168 static void
 169 soft_renderbuffer_delete(struct gl_renderbuffer *rb)
 170 {
 171    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 172
 173    if (srb->Buffer) {
 174       free(srb->Buffer);
 175       srb->Buffer = NULL;
 176    }
 177    free(srb);
 178 }
 179
 180
 181 void
 182 _swrast_map_soft_renderbuffer(struct gl_context *ctx,
 183                               struct gl_renderbuffer *rb,
 184                               GLuint x, GLuint y, GLuint w, GLuint h,
 185                               GLbitfield mode,
 186                               GLubyte **out_map,
 187                               GLint *out_stride)
 188 {
 189    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 190    GLubyte *map = srb->Buffer;
 191    int cpp = _mesa_get_format_bytes(rb->Format);
 192    int stride = rb->Width * cpp;
 193
 194    if (!map) {
 195       *out_map = NULL;
 196       *out_stride = 0;
 197    }
 198
 199    map += y * stride;
 200    map += x * cpp;
 201
 202    *out_map = map;
 203    *out_stride = stride;
 204 }
 205
 206
 207 void
 208 _swrast_unmap_soft_renderbuffer(struct gl_context *ctx,
 209                                 struct gl_renderbuffer *rb)
 210 {
 211 }
 212
 213
 214
 215 /**
 216  * Allocate a software-based renderbuffer.  This is called via the
 217  * ctx->Driver.NewRenderbuffer() function when the user creates a new
 218  * renderbuffer.
 219  * This would not be used for hardware-based renderbuffers.
 220  */
 221 struct gl_renderbuffer *
 222 _swrast_new_soft_renderbuffer(struct gl_context *ctx, GLuint name)
 223 {
 224    struct swrast_renderbuffer *srb = CALLOC_STRUCT(swrast_renderbuffer);
 225    if (srb) {
 226       _mesa_init_renderbuffer(&srb->Base, name);
 227       srb->Base.AllocStorage = soft_renderbuffer_storage;
 228       srb->Base.Delete = soft_renderbuffer_delete;
 229    }
 230    return &srb->Base;
 231 }
 232
 233
 234 /**
 235  * Add software-based color renderbuffers to the given framebuffer.
 236  * This is a helper routine for device drivers when creating a
 237  * window system framebuffer (not a user-created render/framebuffer).
 238  * Once this function is called, you can basically forget about this
 239  * renderbuffer; core Mesa will handle all the buffer management and
 240  * rendering!
 241  */
 242 static GLboolean
 243 add_color_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb,
 244                         GLuint rgbBits, GLuint alphaBits,
 245                         GLboolean frontLeft, GLboolean backLeft,
 246                         GLboolean frontRight, GLboolean backRight)
 247 {
 248    gl_buffer_index b;
 249
 250    if (rgbBits > 16 || alphaBits > 16) {
 251       _mesa_problem(ctx,
 252                     "Unsupported bit depth in add_color_renderbuffers");
 253       return GL_FALSE;
 254    }
 255
 256    assert(MAX_COLOR_ATTACHMENTS >= 4);
 257
 258    for (b = BUFFER_FRONT_LEFT; b <= BUFFER_BACK_RIGHT; b++) {
 259       struct gl_renderbuffer *rb;
 260
 261       if (b == BUFFER_FRONT_LEFT && !frontLeft)
 262          continue;
 263       else if (b == BUFFER_BACK_LEFT && !backLeft)
 264          continue;
 265       else if (b == BUFFER_FRONT_RIGHT && !frontRight)
 266          continue;
 267       else if (b == BUFFER_BACK_RIGHT && !backRight)
 268          continue;
 269
 270       assert(fb->Attachment[b].Renderbuffer == NULL);
 271
 272       rb = ctx->Driver.NewRenderbuffer(ctx, 0);
 273       if (!rb) {
 274          _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating color buffer");
 275          return GL_FALSE;
 276       }
 277
 278       rb->InternalFormat = GL_RGBA;
 279
 280       rb->AllocStorage = soft_renderbuffer_storage;
 281       _mesa_add_renderbuffer(fb, b, rb);
 282    }
 283
 284    return GL_TRUE;
 285 }
 286
 287
 288 /**
 289  * Add a software-based depth renderbuffer to the given framebuffer.
 290  * This is a helper routine for device drivers when creating a
 291  * window system framebuffer (not a user-created render/framebuffer).
 292  * Once this function is called, you can basically forget about this
 293  * renderbuffer; core Mesa will handle all the buffer management and
 294  * rendering!
 295  */
 296 static GLboolean
 297 add_depth_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb,
 298                        GLuint depthBits)
 299 {
 300    struct gl_renderbuffer *rb;
 301
 302    if (depthBits > 32) {
 303       _mesa_problem(ctx,
 304                     "Unsupported depthBits in add_depth_renderbuffer");
 305       return GL_FALSE;
 306    }
 307
 308    assert(fb->Attachment[BUFFER_DEPTH].Renderbuffer == NULL);
 309
 310    rb = _swrast_new_soft_renderbuffer(ctx, 0);
 311    if (!rb) {
 312       _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating depth buffer");
 313       return GL_FALSE;
 314    }
 315
 316    if (depthBits <= 16) {
 317       rb->InternalFormat = GL_DEPTH_COMPONENT16;
 318    }
 319    else if (depthBits <= 24) {
 320       rb->InternalFormat = GL_DEPTH_COMPONENT24;
 321    }
 322    else {
 323       rb->InternalFormat = GL_DEPTH_COMPONENT32;
 324    }
 325
 326    rb->AllocStorage = soft_renderbuffer_storage;
 327    _mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb);
 328
 329    return GL_TRUE;
 330 }
 331
 332
 333 /**
 334  * Add a software-based stencil renderbuffer to the given framebuffer.
 335  * This is a helper routine for device drivers when creating a
 336  * window system framebuffer (not a user-created render/framebuffer).
 337  * Once this function is called, you can basically forget about this
 338  * renderbuffer; core Mesa will handle all the buffer management and
 339  * rendering!
 340  */
 341 static GLboolean
 342 add_stencil_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb,
 343                          GLuint stencilBits)
 344 {
 345    struct gl_renderbuffer *rb;
 346
 347    if (stencilBits > 16) {
 348       _mesa_problem(ctx,
 349                   "Unsupported stencilBits in add_stencil_renderbuffer");
 350       return GL_FALSE;
 351    }
 352
 353    assert(fb->Attachment[BUFFER_STENCIL].Renderbuffer == NULL);
 354
 355    rb = _swrast_new_soft_renderbuffer(ctx, 0);
 356    if (!rb) {
 357       _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating stencil buffer");
 358       return GL_FALSE;
 359    }
 360
 361    assert(stencilBits <= 8);
 362    rb->InternalFormat = GL_STENCIL_INDEX8;
 363
 364    rb->AllocStorage = soft_renderbuffer_storage;
 365    _mesa_add_renderbuffer(fb, BUFFER_STENCIL, rb);
 366
 367    return GL_TRUE;
 368 }
 369
 370
 371 static GLboolean
 372 add_depth_stencil_renderbuffer(struct gl_context *ctx,
 373                                struct gl_framebuffer *fb)
 374 {
 375    struct gl_renderbuffer *rb;
 376
 377    assert(fb->Attachment[BUFFER_DEPTH].Renderbuffer == NULL);
 378    assert(fb->Attachment[BUFFER_STENCIL].Renderbuffer == NULL);
 379
 380    rb = _swrast_new_soft_renderbuffer(ctx, 0);
 381    if (!rb) {
 382       _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating depth+stencil buffer");
 383       return GL_FALSE;
 384    }
 385
 386    rb->InternalFormat = GL_DEPTH_STENCIL;
 387
 388    rb->AllocStorage = soft_renderbuffer_storage;
 389    _mesa_add_renderbuffer(fb, BUFFER_DEPTH, rb);
 390    _mesa_add_renderbuffer(fb, BUFFER_STENCIL, rb);
 391
 392    return GL_TRUE;
 393 }
 394
 395
 396 /**
 397  * Add a software-based accumulation renderbuffer to the given framebuffer.
 398  * This is a helper routine for device drivers when creating a
 399  * window system framebuffer (not a user-created render/framebuffer).
 400  * Once this function is called, you can basically forget about this
 401  * renderbuffer; core Mesa will handle all the buffer management and
 402  * rendering!
 403  */
 404 static GLboolean
 405 add_accum_renderbuffer(struct gl_context *ctx, struct gl_framebuffer *fb,
 406                        GLuint redBits, GLuint greenBits,
 407                        GLuint blueBits, GLuint alphaBits)
 408 {
 409    struct gl_renderbuffer *rb;
 410
 411    if (redBits > 16 || greenBits > 16 || blueBits > 16 || alphaBits > 16) {
 412       _mesa_problem(ctx,
 413                     "Unsupported accumBits in add_accum_renderbuffer");
 414       return GL_FALSE;
 415    }
 416
 417    assert(fb->Attachment[BUFFER_ACCUM].Renderbuffer == NULL);
 418
 419    rb = _swrast_new_soft_renderbuffer(ctx, 0);
 420    if (!rb) {
 421       _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating accum buffer");
 422       return GL_FALSE;
 423    }
 424
 425    rb->InternalFormat = GL_RGBA16_SNORM;
 426    rb->AllocStorage = soft_renderbuffer_storage;
 427    _mesa_add_renderbuffer(fb, BUFFER_ACCUM, rb);
 428
 429    return GL_TRUE;
 430 }
 431
 432
 433
 434 /**
 435  * Add a software-based aux renderbuffer to the given framebuffer.
 436  * This is a helper routine for device drivers when creating a
 437  * window system framebuffer (not a user-created render/framebuffer).
 438  * Once this function is called, you can basically forget about this
 439  * renderbuffer; core Mesa will handle all the buffer management and
 440  * rendering!
 441  *
 442  * NOTE: color-index aux buffers not supported.
 443  */
 444 static GLboolean
 445 add_aux_renderbuffers(struct gl_context *ctx, struct gl_framebuffer *fb,
 446                       GLuint colorBits, GLuint numBuffers)
 447 {
 448    GLuint i;
 449
 450    if (colorBits > 16) {
 451       _mesa_problem(ctx,
 452                     "Unsupported colorBits in add_aux_renderbuffers");
 453       return GL_FALSE;
 454    }
 455
 456    assert(numBuffers <= MAX_AUX_BUFFERS);
 457
 458    for (i = 0; i < numBuffers; i++) {
 459       struct gl_renderbuffer *rb = _swrast_new_soft_renderbuffer(ctx, 0);
 460
 461       assert(fb->Attachment[BUFFER_AUX0 + i].Renderbuffer == NULL);
 462
 463       if (!rb) {
 464          _mesa_error(ctx, GL_OUT_OF_MEMORY, "Allocating aux buffer");
 465          return GL_FALSE;
 466       }
 467
 468       assert (colorBits <= 8);
 469       rb->InternalFormat = GL_RGBA;
 470
 471       rb->AllocStorage = soft_renderbuffer_storage;
 472       _mesa_add_renderbuffer(fb, BUFFER_AUX0 + i, rb);
 473    }
 474    return GL_TRUE;
 475 }
 476
 477
 478 /**
 479  * Create/attach software-based renderbuffers to the given framebuffer.
 480  * This is a helper routine for device drivers.  Drivers can just as well
 481  * call the individual _mesa_add_*_renderbuffer() routines directly.
 482  */
 483 void
 484 _swrast_add_soft_renderbuffers(struct gl_framebuffer *fb,
 485                                GLboolean color,
 486                                GLboolean depth,
 487                                GLboolean stencil,
 488                                GLboolean accum,
 489                                GLboolean alpha,
 490                                GLboolean aux)
 491 {
 492    GLboolean frontLeft = GL_TRUE;
 493    GLboolean backLeft = fb->Visual.doubleBufferMode;
 494    GLboolean frontRight = fb->Visual.stereoMode;
 495    GLboolean backRight = fb->Visual.stereoMode && fb->Visual.doubleBufferMode;
 496
 497    if (color) {
 498       assert(fb->Visual.redBits == fb->Visual.greenBits);
 499       assert(fb->Visual.redBits == fb->Visual.blueBits);
 500       add_color_renderbuffers(NULL, fb,
 501                               fb->Visual.redBits,
 502                               fb->Visual.alphaBits,
 503                               frontLeft, backLeft,
 504                               frontRight, backRight);
 505    }
 506
 507 #if 0
 508    /* This is pretty much for debugging purposes only since there's a perf
 509     * hit for using combined depth/stencil in swrast.
 510     */
 511    if (depth && fb->Visual.depthBits == 24 &&
 512        stencil && fb->Visual.stencilBits == 8) {
 513       /* use combined depth/stencil buffer */
 514       add_depth_stencil_renderbuffer(NULL, fb);
 515    }
 516    else
 517 #else
 518    (void) add_depth_stencil_renderbuffer;
 519 #endif
 520    {
 521       if (depth) {
 522          assert(fb->Visual.depthBits > 0);
 523          add_depth_renderbuffer(NULL, fb, fb->Visual.depthBits);
 524       }
 525
 526       if (stencil) {
 527          assert(fb->Visual.stencilBits > 0);
 528          add_stencil_renderbuffer(NULL, fb, fb->Visual.stencilBits);
 529       }
 530    }
 531
 532    if (accum) {
 533       assert(fb->Visual.accumRedBits > 0);
 534       assert(fb->Visual.accumGreenBits > 0);
 535       assert(fb->Visual.accumBlueBits > 0);
 536       add_accum_renderbuffer(NULL, fb,
 537                              fb->Visual.accumRedBits,
 538                              fb->Visual.accumGreenBits,
 539                              fb->Visual.accumBlueBits,
 540                              fb->Visual.accumAlphaBits);
 541    }
 542
 543    if (aux) {
 544       assert(fb->Visual.numAuxBuffers > 0);
 545       add_aux_renderbuffers(NULL, fb, fb->Visual.redBits,
 546                             fb->Visual.numAuxBuffers);
 547    }
 548
 549 #if 0
 550    if (multisample) {
 551       /* maybe someday */
 552    }
 553 #endif
 554 }
 555
 556
 557
 558 static void
 559 map_attachment(struct gl_context *ctx,
 560                  struct gl_framebuffer *fb,
 561                  gl_buffer_index buffer)
 562 {
 563    struct gl_texture_object *texObj = fb->Attachment[buffer].Texture;
 564    struct gl_renderbuffer *rb = fb->Attachment[buffer].Renderbuffer;
 565    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 566
 567    if (texObj) {
 568       /* map texture image (render to texture) */
 569       const GLuint level = fb->Attachment[buffer].TextureLevel;
 570       const GLuint face = fb->Attachment[buffer].CubeMapFace;
 571       const GLuint slice = fb->Attachment[buffer].Zoffset;
 572       struct gl_texture_image *texImage = texObj->Image[face][level];
 573       if (texImage) {
 574          ctx->Driver.MapTextureImage(ctx, texImage, slice,
 575                                      0, 0, texImage->Width, texImage->Height,
 576                                      GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 577                                      &srb->Map, &srb->RowStride);
 578       }
 579    }
 580    else if (rb) {
 581       /* Map ordinary renderbuffer */
 582       ctx->Driver.MapRenderbuffer(ctx, rb,
 583                                   0, 0, rb->Width, rb->Height,
 584                                   GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 585                                   &srb->Map, &srb->RowStride);
 586    }
 587
 588    assert(srb->Map);
 589 }
 590
 591
 592 static void
 593 unmap_attachment(struct gl_context *ctx,
 594                    struct gl_framebuffer *fb,
 595                    gl_buffer_index buffer)
 596 {
 597    struct gl_texture_object *texObj = fb->Attachment[buffer].Texture;
 598    struct gl_renderbuffer *rb = fb->Attachment[buffer].Renderbuffer;
 599    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 600
 601    if (texObj) {
 602       /* unmap texture image (render to texture) */
 603       const GLuint level = fb->Attachment[buffer].TextureLevel;
 604       const GLuint face = fb->Attachment[buffer].CubeMapFace;
 605       const GLuint slice = fb->Attachment[buffer].Zoffset;
 606       struct gl_texture_image *texImage = texObj->Image[face][level];
 607       if (texImage) {
 608          ctx->Driver.UnmapTextureImage(ctx, texImage, slice);
 609       }
 610    }
 611    else if (rb) {
 612       /* unmap ordinary renderbuffer */
 613       ctx->Driver.UnmapRenderbuffer(ctx, rb);
 614    }
 615
 616    srb->Map = NULL;
 617 }
 618
 619
 620 /**
 621  * Determine what type to use (ubyte vs. float) for span colors for the
 622  * given renderbuffer.
 623  * See also _swrast_write_rgba_span().
 624  */
 625 static void
 626 find_renderbuffer_colortype(struct gl_renderbuffer *rb)
 627 {
 628    struct swrast_renderbuffer *srb = swrast_renderbuffer(rb);
 629    GLuint rbMaxBits = _mesa_get_format_max_bits(rb->Format);
 630    GLenum rbDatatype = _mesa_get_format_datatype(rb->Format);
 631
 632    if (rbDatatype == GL_UNSIGNED_NORMALIZED && rbMaxBits <= 8) {
 633       /* the buffer's values fit in GLubyte values */
 634       srb->ColorType = GL_UNSIGNED_BYTE;
 635    }
 636    else {
 637       /* use floats otherwise */
 638       srb->ColorType = GL_FLOAT;
 639    }
 640 }
 641
 642
 643 /**
 644  * Map the renderbuffers we'll use for tri/line/point rendering.
 645  */
 646 void
 647 _swrast_map_renderbuffers(struct gl_context *ctx)
 648 {
 649    struct gl_framebuffer *fb = ctx->DrawBuffer;
 650    struct gl_renderbuffer *depthRb, *stencilRb;
 651    GLuint buf;
 652
 653    depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
 654    if (depthRb) {
 655       /* map depth buffer */
 656       map_attachment(ctx, fb, BUFFER_DEPTH);
 657    }
 658
 659    stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
 660    if (stencilRb && stencilRb != depthRb) {
 661       /* map stencil buffer */
 662       map_attachment(ctx, fb, BUFFER_STENCIL);
 663    }
 664
 665    for (buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
 666       map_attachment(ctx, fb, fb->_ColorDrawBufferIndexes[buf]);
 667       find_renderbuffer_colortype(fb->_ColorDrawBuffers[buf]);
 668    }
 669 }
 670
 671
 672 /**
 673  * Unmap renderbuffers after rendering.
 674  */
 675 void
 676 _swrast_unmap_renderbuffers(struct gl_context *ctx)
 677 {
 678    struct gl_framebuffer *fb = ctx->DrawBuffer;
 679    struct gl_renderbuffer *depthRb, *stencilRb;
 680    GLuint buf;
 681
 682    depthRb = fb->Attachment[BUFFER_DEPTH].Renderbuffer;
 683    if (depthRb) {
 684       /* map depth buffer */
 685       unmap_attachment(ctx, fb, BUFFER_DEPTH);
 686    }
 687
 688    stencilRb = fb->Attachment[BUFFER_STENCIL].Renderbuffer;
 689    if (stencilRb && stencilRb != depthRb) {
 690       /* map stencil buffer */
 691       unmap_attachment(ctx, fb, BUFFER_STENCIL);
 692    }
 693
 694    for (buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
 695       unmap_attachment(ctx, fb, fb->_ColorDrawBufferIndexes[buf]);
 696    }
 697 }