src/mesa/main/buffers.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  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  * \file buffers.c
  28  * glReadBuffer, DrawBuffer functions.
  29  */
  30
  31
  32
  33 #include "glheader.h"
  34 #include "buffers.h"
  35 #include "colormac.h"
  36 #include "context.h"
  37 #include "enums.h"
  38 #include "fbobject.h"
  39 #include "state.h"
  40
  41
  42 #define BAD_MASK ~0u
  43
  44
  45 /**
  46  * Return bitmask of BUFFER_BIT_* flags indicating which color buffers are
  47  * available to the rendering context (for drawing or reading).
  48  * This depends on the type of framebuffer.  For window system framebuffers
  49  * we look at the framebuffer's visual.  But for user-create framebuffers we
  50  * look at the number of supported color attachments.
  51  * \param fb  the framebuffer to draw to, or read from
  52  * \return  bitmask of BUFFER_BIT_* flags
  53  */
  54 static GLbitfield
  55 supported_buffer_bitmask(const GLcontext *ctx, const struct gl_framebuffer *fb)
  56 {
  57    GLbitfield mask = 0x0;
  58
  59    if (fb->Name > 0) {
  60       /* A user-created renderbuffer */
  61       GLuint i;
  62       ASSERT(ctx->Extensions.EXT_framebuffer_object);
  63       for (i = 0; i < ctx->Const.MaxColorAttachments; i++) {
  64          mask |= (BUFFER_BIT_COLOR0 << i);
  65       }
  66    }
  67    else {
  68       /* A window system framebuffer */
  69       GLint i;
  70       mask = BUFFER_BIT_FRONT_LEFT; /* always have this */
  71       if (fb->Visual.stereoMode) {
  72          mask |= BUFFER_BIT_FRONT_RIGHT;
  73          if (fb->Visual.doubleBufferMode) {
  74             mask |= BUFFER_BIT_BACK_LEFT | BUFFER_BIT_BACK_RIGHT;
  75          }
  76       }
  77       else if (fb->Visual.doubleBufferMode) {
  78          mask |= BUFFER_BIT_BACK_LEFT;
  79       }
  80
  81       for (i = 0; i < fb->Visual.numAuxBuffers; i++) {
  82          mask |= (BUFFER_BIT_AUX0 << i);
  83       }
  84    }
  85
  86    return mask;
  87 }
  88
  89
  90 /**
  91  * Helper routine used by glDrawBuffer and glDrawBuffersARB.
  92  * Given a GLenum naming one or more color buffers (such as
  93  * GL_FRONT_AND_BACK), return the corresponding bitmask of BUFFER_BIT_* flags.
  94  */
  95 static GLbitfield
  96 draw_buffer_enum_to_bitmask(GLenum buffer)
  97 {
  98    switch (buffer) {
  99       case GL_NONE:
 100          return 0;
 101       case GL_FRONT:
 102          return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_FRONT_RIGHT;
 103       case GL_BACK:
 104          return BUFFER_BIT_BACK_LEFT | BUFFER_BIT_BACK_RIGHT;
 105       case GL_RIGHT:
 106          return BUFFER_BIT_FRONT_RIGHT | BUFFER_BIT_BACK_RIGHT;
 107       case GL_FRONT_RIGHT:
 108          return BUFFER_BIT_FRONT_RIGHT;
 109       case GL_BACK_RIGHT:
 110          return BUFFER_BIT_BACK_RIGHT;
 111       case GL_BACK_LEFT:
 112          return BUFFER_BIT_BACK_LEFT;
 113       case GL_FRONT_AND_BACK:
 114          return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT
 115               | BUFFER_BIT_FRONT_RIGHT | BUFFER_BIT_BACK_RIGHT;
 116       case GL_LEFT:
 117          return BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT;
 118       case GL_FRONT_LEFT:
 119          return BUFFER_BIT_FRONT_LEFT;
 120       case GL_AUX0:
 121          return BUFFER_BIT_AUX0;
 122       case GL_COLOR_ATTACHMENT0_EXT:
 123          return BUFFER_BIT_COLOR0;
 124       case GL_COLOR_ATTACHMENT1_EXT:
 125          return BUFFER_BIT_COLOR1;
 126       case GL_COLOR_ATTACHMENT2_EXT:
 127          return BUFFER_BIT_COLOR2;
 128       case GL_COLOR_ATTACHMENT3_EXT:
 129          return BUFFER_BIT_COLOR3;
 130       case GL_COLOR_ATTACHMENT4_EXT:
 131          return BUFFER_BIT_COLOR4;
 132       case GL_COLOR_ATTACHMENT5_EXT:
 133          return BUFFER_BIT_COLOR5;
 134       case GL_COLOR_ATTACHMENT6_EXT:
 135          return BUFFER_BIT_COLOR6;
 136       case GL_COLOR_ATTACHMENT7_EXT:
 137          return BUFFER_BIT_COLOR7;
 138       default:
 139          /* error */
 140          return BAD_MASK;
 141    }
 142 }
 143
 144
 145 /**
 146  * Helper routine used by glReadBuffer.
 147  * Given a GLenum naming a color buffer, return the index of the corresponding
 148  * renderbuffer (a BUFFER_* value).
 149  * return -1 for an invalid buffer.
 150  */
 151 static GLint
 152 read_buffer_enum_to_index(GLenum buffer)
 153 {
 154    switch (buffer) {
 155       case GL_FRONT:
 156          return BUFFER_FRONT_LEFT;
 157       case GL_BACK:
 158          return BUFFER_BACK_LEFT;
 159       case GL_RIGHT:
 160          return BUFFER_FRONT_RIGHT;
 161       case GL_FRONT_RIGHT:
 162          return BUFFER_FRONT_RIGHT;
 163       case GL_BACK_RIGHT:
 164          return BUFFER_BACK_RIGHT;
 165       case GL_BACK_LEFT:
 166          return BUFFER_BACK_LEFT;
 167       case GL_LEFT:
 168          return BUFFER_FRONT_LEFT;
 169       case GL_FRONT_LEFT:
 170          return BUFFER_FRONT_LEFT;
 171       case GL_AUX0:
 172          return BUFFER_AUX0;
 173       case GL_COLOR_ATTACHMENT0_EXT:
 174          return BUFFER_COLOR0;
 175       case GL_COLOR_ATTACHMENT1_EXT:
 176          return BUFFER_COLOR1;
 177       case GL_COLOR_ATTACHMENT2_EXT:
 178          return BUFFER_COLOR2;
 179       case GL_COLOR_ATTACHMENT3_EXT:
 180          return BUFFER_COLOR3;
 181       case GL_COLOR_ATTACHMENT4_EXT:
 182          return BUFFER_COLOR4;
 183       case GL_COLOR_ATTACHMENT5_EXT:
 184          return BUFFER_COLOR5;
 185       case GL_COLOR_ATTACHMENT6_EXT:
 186          return BUFFER_COLOR6;
 187       case GL_COLOR_ATTACHMENT7_EXT:
 188          return BUFFER_COLOR7;
 189       default:
 190          /* error */
 191          return -1;
 192    }
 193 }
 194
 195
 196 /**
 197  * Called by glDrawBuffer().
 198  * Specify which renderbuffer(s) to draw into for the first color output.
 199  * <buffer> can name zero, one, two or four renderbuffers!
 200  * \sa _mesa_DrawBuffersARB
 201  *
 202  * \param buffer  buffer token such as GL_LEFT or GL_FRONT_AND_BACK, etc.
 203  *
 204  * Note that the behaviour of this function depends on whether the
 205  * current ctx->DrawBuffer is a window-system framebuffer (Name=0) or
 206  * a user-created framebuffer object (Name!=0).
 207  *   In the former case, we update the per-context ctx->Color.DrawBuffer
 208  *   state var _and_ the FB's ColorDrawBuffer state.
 209  *   In the later case, we update the FB's ColorDrawBuffer state only.
 210  *
 211  * Furthermore, upon a MakeCurrent() or BindFramebuffer() call, if the
 212  * new FB is a window system FB, we need to re-update the FB's
 213  * ColorDrawBuffer state to match the context.  This is handled in
 214  * _mesa_update_framebuffer().
 215  *
 216  * See the GL_EXT_framebuffer_object spec for more info.
 217  */
 218 void GLAPIENTRY
 219 _mesa_DrawBuffer(GLenum buffer)
 220 {
 221    GLbitfield destMask;
 222    GET_CURRENT_CONTEXT(ctx);
 223    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx); /* too complex... */
 224
 225    if (MESA_VERBOSE & VERBOSE_API) {
 226       _mesa_debug(ctx, "glDrawBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
 227    }
 228
 229    if (buffer == GL_NONE) {
 230       destMask = 0x0;
 231    }
 232    else {
 233       const GLbitfield supportedMask
 234          = supported_buffer_bitmask(ctx, ctx->DrawBuffer);
 235       destMask = draw_buffer_enum_to_bitmask(buffer);
 236       if (destMask == BAD_MASK) {
 237          /* totally bogus buffer */
 238          _mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffer(buffer=0x%x)", buffer);
 239          return;
 240       }
 241       destMask &= supportedMask;
 242       if (destMask == 0x0) {
 243          /* none of the named color buffers exist! */
 244          _mesa_error(ctx, GL_INVALID_OPERATION,
 245                      "glDrawBuffer(buffer=0x%x)", buffer);
 246          return;
 247       }
 248    }
 249
 250    /* if we get here, there's no error so set new state */
 251    _mesa_drawbuffers(ctx, 1, &buffer, &destMask);
 252
 253    /*
 254     * Call device driver function.
 255     */
 256    if (ctx->Driver.DrawBuffers)
 257       ctx->Driver.DrawBuffers(ctx, 1, &buffer);
 258    else if (ctx->Driver.DrawBuffer)
 259       ctx->Driver.DrawBuffer(ctx, buffer);
 260 }
 261
 262
 263 /**
 264  * Called by glDrawBuffersARB; specifies the destination color renderbuffers
 265  * for N fragment program color outputs.
 266  * \sa _mesa_DrawBuffer
 267  * \param n  number of outputs
 268  * \param buffers  array [n] of renderbuffer names.  Unlike glDrawBuffer, the
 269  *                 names cannot specify more than one buffer.  For example,
 270  *                 GL_FRONT_AND_BACK is illegal.
 271  */
 272 void GLAPIENTRY
 273 _mesa_DrawBuffersARB(GLsizei n, const GLenum *buffers)
 274 {
 275    GLint output;
 276    GLbitfield usedBufferMask, supportedMask;
 277    GLbitfield destMask[MAX_DRAW_BUFFERS];
 278    GET_CURRENT_CONTEXT(ctx);
 279    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 280
 281    /* Turns out n==0 is a valid input that should not produce an error.
 282     * The remaining code below correctly handles the n==0 case.
 283     */
 284    if (n < 0 || n > (GLsizei) ctx->Const.MaxDrawBuffers) {
 285       _mesa_error(ctx, GL_INVALID_VALUE, "glDrawBuffersARB(n)");
 286       return;
 287    }
 288
 289    supportedMask = supported_buffer_bitmask(ctx, ctx->DrawBuffer);
 290    usedBufferMask = 0x0;
 291
 292    /* complicated error checking... */
 293    for (output = 0; output < n; output++) {
 294       if (buffers[output] == GL_NONE) {
 295          destMask[output] = 0x0;
 296       }
 297       else {
 298          destMask[output] = draw_buffer_enum_to_bitmask(buffers[output]);
 299          if (destMask[output] == BAD_MASK
 300              || _mesa_bitcount(destMask[output]) > 1) {
 301             _mesa_error(ctx, GL_INVALID_ENUM, "glDrawBuffersARB(buffer)");
 302             return;
 303          }
 304          destMask[output] &= supportedMask;
 305          if (destMask[output] == 0) {
 306             _mesa_error(ctx, GL_INVALID_OPERATION,
 307                         "glDrawBuffersARB(unsupported buffer)");
 308             return;
 309          }
 310          if (destMask[output] & usedBufferMask) {
 311             /* can't specify a dest buffer more than once! */
 312             _mesa_error(ctx, GL_INVALID_OPERATION,
 313                         "glDrawBuffersARB(duplicated buffer)");
 314             return;
 315          }
 316
 317          /* update bitmask */
 318          usedBufferMask |= destMask[output];
 319       }
 320    }
 321
 322    /* OK, if we get here, there were no errors so set the new state */
 323    _mesa_drawbuffers(ctx, n, buffers, destMask);
 324
 325    /*
 326     * Call device driver function.  Note that n can be equal to 0,
 327     * in which case we don't want to reference buffers[0], which
 328     * may not be valid.
 329     */
 330    if (ctx->Driver.DrawBuffers)
 331       ctx->Driver.DrawBuffers(ctx, n, buffers);
 332    else if (ctx->Driver.DrawBuffer)
 333       ctx->Driver.DrawBuffer(ctx, n>0? buffers[0]:GL_NONE);
 334 }
 335
 336
 337 /**
 338  * Helper function to set the GL_DRAW_BUFFER state in the context and
 339  * current FBO.
 340  *
 341  * All error checking will have been done prior to calling this function
 342  * so nothing should go wrong at this point.
 343  *
 344  * \param ctx  current context
 345  * \param n    number of color outputs to set
 346  * \param buffers  array[n] of colorbuffer names, like GL_LEFT.
 347  * \param destMask  array[n] of BUFFER_BIT_* bitmasks which correspond to the
 348  *                  colorbuffer names.  (i.e. GL_FRONT_AND_BACK =>
 349  *                  BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT).
 350  */
 351 void
 352 _mesa_drawbuffers(GLcontext *ctx, GLuint n, const GLenum *buffers,
 353                   const GLbitfield *destMask)
 354 {
 355    struct gl_framebuffer *fb = ctx->DrawBuffer;
 356    GLbitfield mask[MAX_DRAW_BUFFERS];
 357
 358    if (!destMask) {
 359       /* compute destMask values now */
 360       const GLbitfield supportedMask = supported_buffer_bitmask(ctx, fb);
 361       GLuint output;
 362       for (output = 0; output < n; output++) {
 363          mask[output] = draw_buffer_enum_to_bitmask(buffers[output]);
 364          ASSERT(mask[output] != BAD_MASK);
 365          mask[output] &= supportedMask;
 366       }
 367       destMask = mask;
 368    }
 369
 370    if (n == 1) {
 371       GLuint buf, count = 0;
 372       /* init to -1 to help catch errors */
 373       fb->_ColorDrawBufferIndexes[0] = -1;
 374       for (buf = 0; buf < BUFFER_COUNT; buf++) {
 375          if (destMask[0] & (1 << buf)) {
 376             fb->_ColorDrawBufferIndexes[count] = buf;
 377             count++;
 378          }
 379       }
 380       fb->ColorDrawBuffer[0] = buffers[0];
 381       fb->_NumColorDrawBuffers = count;
 382    }
 383    else {
 384       GLuint buf, count = 0;
 385       for (buf = 0; buf < n; buf++ ) {
 386          if (destMask[buf]) {
 387             fb->_ColorDrawBufferIndexes[buf] = _mesa_ffs(destMask[buf]) - 1;
 388             fb->ColorDrawBuffer[buf] = buffers[buf];
 389             count = buf + 1;
 390          }
 391          else {
 392             fb->_ColorDrawBufferIndexes[buf] = -1;
 393          }
 394       }
 395       /* set remaining outputs to -1 (GL_NONE) */
 396       while (buf < ctx->Const.MaxDrawBuffers) {
 397          fb->_ColorDrawBufferIndexes[buf] = -1;
 398          fb->ColorDrawBuffer[buf] = GL_NONE;
 399          buf++;
 400       }
 401       fb->_NumColorDrawBuffers = count;
 402    }
 403
 404    if (fb->Name == 0) {
 405       /* also set context drawbuffer state */
 406       GLuint buf;
 407       for (buf = 0; buf < ctx->Const.MaxDrawBuffers; buf++) {
 408          ctx->Color.DrawBuffer[buf] = fb->ColorDrawBuffer[buf];
 409       }
 410    }
 411
 412    ctx->NewState |= _NEW_BUFFERS;
 413 }
 414
 415
 416 /**
 417  * Like \sa _mesa_drawbuffers(), this is a helper function for setting
 418  * GL_READ_BUFFER state in the context and current FBO.
 419  * \param ctx  the rendering context
 420  * \param buffer  GL_FRONT, GL_BACK, GL_COLOR_ATTACHMENT0, etc.
 421  * \param bufferIndex  the numerical index corresponding to 'buffer'
 422  */
 423 void
 424 _mesa_readbuffer(GLcontext *ctx, GLenum buffer, GLint bufferIndex)
 425 {
 426    struct gl_framebuffer *fb = ctx->ReadBuffer;
 427
 428    if (fb->Name == 0) {
 429       /* Only update the per-context READ_BUFFER state if we're bound to
 430        * a window-system framebuffer.
 431        */
 432       ctx->Pixel.ReadBuffer = buffer;
 433    }
 434
 435    fb->ColorReadBuffer = buffer;
 436    fb->_ColorReadBufferIndex = bufferIndex;
 437
 438    ctx->NewState |= _NEW_PIXEL;
 439 }
 440
 441
 442
 443 /**
 444  * Called by glReadBuffer to set the source renderbuffer for reading pixels.
 445  * \param mode color buffer such as GL_FRONT, GL_BACK, etc.
 446  */
 447 void GLAPIENTRY
 448 _mesa_ReadBuffer(GLenum buffer)
 449 {
 450    struct gl_framebuffer *fb;
 451    GLbitfield supportedMask;
 452    GLint srcBuffer;
 453    GET_CURRENT_CONTEXT(ctx);
 454    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
 455
 456    if (MESA_VERBOSE & VERBOSE_API)
 457       _mesa_debug(ctx, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
 458
 459    fb = ctx->ReadBuffer;
 460
 461    if (MESA_VERBOSE & VERBOSE_API)
 462       _mesa_debug(ctx, "glReadBuffer %s\n", _mesa_lookup_enum_by_nr(buffer));
 463
 464    if (fb->Name > 0 && buffer == GL_NONE) {
 465       /* This is legal for user-created framebuffer objects */
 466       srcBuffer = -1;
 467    }
 468    else {
 469       /* general case / window-system framebuffer */
 470       srcBuffer = read_buffer_enum_to_index(buffer);
 471       if (srcBuffer == -1) {
 472          _mesa_error(ctx, GL_INVALID_ENUM,
 473                      "glReadBuffer(buffer=0x%x)", buffer);
 474          return;
 475       }
 476       supportedMask = supported_buffer_bitmask(ctx, fb);
 477       if (((1 << srcBuffer) & supportedMask) == 0) {
 478          _mesa_error(ctx, GL_INVALID_OPERATION,
 479                      "glReadBuffer(buffer=0x%x)", buffer);
 480          return;
 481       }
 482    }
 483
 484    /* OK, all error checking has been completed now */
 485
 486    _mesa_readbuffer(ctx, buffer, srcBuffer);
 487    ctx->NewState |= _NEW_BUFFERS;
 488
 489    /*
 490     * Call device driver function.
 491     */
 492    if (ctx->Driver.ReadBuffer)
 493       (*ctx->Driver.ReadBuffer)(ctx, buffer);
 494 }