src/mesa/main/accum.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 1999-2005  Brian Paul   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 "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "glheader.h"
  26 #include "accum.h"
  27 #include "condrender.h"
  28 #include "context.h"
  29 #include "format_unpack.h"
  30 #include "format_pack.h"
  31 #include "framebuffer.h"
  32
  33 #include "macros.h"
  34 #include "state.h"
  35 #include "mtypes.h"
  36
  37
  38 void GLAPIENTRY
  39 _mesa_ClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  40 {
  41    GLfloat tmp[4];
  42    GET_CURRENT_CONTEXT(ctx);
  43
  44    tmp[0] = CLAMP( red,   -1.0F, 1.0F );
  45    tmp[1] = CLAMP( green, -1.0F, 1.0F );
  46    tmp[2] = CLAMP( blue,  -1.0F, 1.0F );
  47    tmp[3] = CLAMP( alpha, -1.0F, 1.0F );
  48
  49    if (TEST_EQ_4V(tmp, ctx->Accum.ClearColor))
  50       return;
  51
  52    COPY_4FV( ctx->Accum.ClearColor, tmp );
  53 }
  54
  55
  56 /**
  57  * Clear the accumulation buffer by mapping the renderbuffer and
  58  * writing the clear color to it.  Called by the driver's implementation
  59  * of the glClear function.
  60  */
  61 void
  62 _mesa_clear_accum_buffer(struct gl_context *ctx)
  63 {
  64    GLuint x, y, width, height;
  65    GLubyte *accMap;
  66    GLint accRowStride;
  67    struct gl_renderbuffer *accRb;
  68
  69    if (!ctx->DrawBuffer)
  70       return;
  71
  72    accRb = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
  73    if (!accRb)
  74       return;   /* missing accum buffer, not an error */
  75
  76    _mesa_update_draw_buffer_bounds(ctx, ctx->DrawBuffer);
  77
  78    /* bounds, with scissor */
  79    x = ctx->DrawBuffer->_Xmin;
  80    y = ctx->DrawBuffer->_Ymin;
  81    width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
  82    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
  83
  84    ctx->Driver.MapRenderbuffer(ctx, accRb, x, y, width, height,
  85                                GL_MAP_WRITE_BIT, &accMap, &accRowStride,
  86                                ctx->DrawBuffer->FlipY);
  87
  88    if (!accMap) {
  89       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
  90       return;
  91    }
  92
  93    if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
  94       const GLshort clearR = FLOAT_TO_SHORT(ctx->Accum.ClearColor[0]);
  95       const GLshort clearG = FLOAT_TO_SHORT(ctx->Accum.ClearColor[1]);
  96       const GLshort clearB = FLOAT_TO_SHORT(ctx->Accum.ClearColor[2]);
  97       const GLshort clearA = FLOAT_TO_SHORT(ctx->Accum.ClearColor[3]);
  98       GLuint i, j;
  99
 100       for (j = 0; j < height; j++) {
 101          GLshort *row = (GLshort *) accMap;
 102
 103          for (i = 0; i < width; i++) {
 104             row[i * 4 + 0] = clearR;
 105             row[i * 4 + 1] = clearG;
 106             row[i * 4 + 2] = clearB;
 107             row[i * 4 + 3] = clearA;
 108          }
 109          accMap += accRowStride;
 110       }
 111    }
 112    else {
 113       /* other types someday? */
 114       _mesa_warning(ctx, "unexpected accum buffer type");
 115    }
 116
 117    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 118 }
 119
 120
 121 /**
 122  * if (bias)
 123  *    Accum += value
 124  * else
 125  *    Accum *= value
 126  */
 127 static void
 128 accum_scale_or_bias(struct gl_context *ctx, GLfloat value,
 129                     GLint xpos, GLint ypos, GLint width, GLint height,
 130                     GLboolean bias)
 131 {
 132    struct gl_renderbuffer *accRb =
 133       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
 134    GLubyte *accMap;
 135    GLint accRowStride;
 136
 137    assert(accRb);
 138
 139    ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,
 140                                GL_MAP_READ_BIT | GL_MAP_WRITE_BIT,
 141                                &accMap, &accRowStride,
 142                                ctx->DrawBuffer->FlipY);
 143
 144    if (!accMap) {
 145       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 146       return;
 147    }
 148
 149    if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 150       const GLshort incr = (GLshort) (value * 32767.0f);
 151       GLint i, j;
 152       if (bias) {
 153          for (j = 0; j < height; j++) {
 154             GLshort *acc = (GLshort *) accMap;
 155             for (i = 0; i < 4 * width; i++) {
 156                acc[i] += incr;
 157             }
 158             accMap += accRowStride;
 159          }
 160       }
 161       else {
 162          /* scale */
 163          for (j = 0; j < height; j++) {
 164             GLshort *acc = (GLshort *) accMap;
 165             for (i = 0; i < 4 * width; i++) {
 166                acc[i] = (GLshort) (acc[i] * value);
 167             }
 168             accMap += accRowStride;
 169          }
 170       }
 171    }
 172    else {
 173       /* other types someday? */
 174    }
 175
 176    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 177 }
 178
 179
 180 /**
 181  * if (load)
 182  *    Accum = ColorBuf * value
 183  * else
 184  *    Accum += ColorBuf * value
 185  */
 186 static void
 187 accum_or_load(struct gl_context *ctx, GLfloat value,
 188               GLint xpos, GLint ypos, GLint width, GLint height,
 189               GLboolean load)
 190 {
 191    struct gl_renderbuffer *accRb =
 192       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
 193    struct gl_renderbuffer *colorRb = ctx->ReadBuffer->_ColorReadBuffer;
 194    GLubyte *accMap, *colorMap;
 195    GLint accRowStride, colorRowStride;
 196    GLbitfield mappingFlags;
 197
 198    if (!colorRb) {
 199       /* no read buffer - OK */
 200       return;
 201    }
 202
 203    assert(accRb);
 204
 205    mappingFlags = GL_MAP_WRITE_BIT;
 206    if (!load) /* if we're accumulating */
 207       mappingFlags |= GL_MAP_READ_BIT;
 208
 209    /* Map accum buffer */
 210    ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,
 211                                mappingFlags, &accMap, &accRowStride,
 212                                ctx->DrawBuffer->FlipY);
 213    if (!accMap) {
 214       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 215       return;
 216    }
 217
 218    /* Map color buffer */
 219    ctx->Driver.MapRenderbuffer(ctx, colorRb, xpos, ypos, width, height,
 220                                GL_MAP_READ_BIT,
 221                                &colorMap, &colorRowStride,
 222                                ctx->DrawBuffer->FlipY);
 223    if (!colorMap) {
 224       ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 225       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 226       return;
 227    }
 228
 229    if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 230       const GLfloat scale = value * 32767.0f;
 231       GLint i, j;
 232       GLfloat (*rgba)[4];
 233
 234       rgba = malloc(width * 4 * sizeof(GLfloat));
 235       if (rgba) {
 236          for (j = 0; j < height; j++) {
 237             GLshort *acc = (GLshort *) accMap;
 238
 239             /* read colors from source color buffer */
 240             _mesa_unpack_rgba_row(colorRb->Format, width, colorMap, rgba);
 241
 242             if (load) {
 243                for (i = 0; i < width; i++) {
 244                   acc[i * 4 + 0] = (GLshort) (rgba[i][RCOMP] * scale);
 245                   acc[i * 4 + 1] = (GLshort) (rgba[i][GCOMP] * scale);
 246                   acc[i * 4 + 2] = (GLshort) (rgba[i][BCOMP] * scale);
 247                   acc[i * 4 + 3] = (GLshort) (rgba[i][ACOMP] * scale);
 248                }
 249             }
 250             else {
 251                /* accumulate */
 252                for (i = 0; i < width; i++) {
 253                   acc[i * 4 + 0] += (GLshort) (rgba[i][RCOMP] * scale);
 254                   acc[i * 4 + 1] += (GLshort) (rgba[i][GCOMP] * scale);
 255                   acc[i * 4 + 2] += (GLshort) (rgba[i][BCOMP] * scale);
 256                   acc[i * 4 + 3] += (GLshort) (rgba[i][ACOMP] * scale);
 257                }
 258             }
 259
 260             colorMap += colorRowStride;
 261             accMap += accRowStride;
 262          }
 263
 264          free(rgba);
 265       }
 266       else {
 267          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 268       }
 269    }
 270    else {
 271       /* other types someday? */
 272    }
 273
 274    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 275    ctx->Driver.UnmapRenderbuffer(ctx, colorRb);
 276 }
 277
 278
 279 /**
 280  * ColorBuffer = Accum * value
 281  */
 282 static void
 283 accum_return(struct gl_context *ctx, GLfloat value,
 284              GLint xpos, GLint ypos, GLint width, GLint height)
 285 {
 286    struct gl_framebuffer *fb = ctx->DrawBuffer;
 287    struct gl_renderbuffer *accRb = fb->Attachment[BUFFER_ACCUM].Renderbuffer;
 288    GLubyte *accMap, *colorMap;
 289    GLint accRowStride, colorRowStride;
 290    GLuint buffer;
 291
 292    /* Map accum buffer */
 293    ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,
 294                                GL_MAP_READ_BIT,
 295                                &accMap, &accRowStride, fb->FlipY);
 296    if (!accMap) {
 297       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 298       return;
 299    }
 300
 301    /* Loop over destination buffers */
 302    for (buffer = 0; buffer < fb->_NumColorDrawBuffers; buffer++) {
 303       struct gl_renderbuffer *colorRb = fb->_ColorDrawBuffers[buffer];
 304       const GLboolean masking = (!GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 0) ||
 305                                  !GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 1) ||
 306                                  !GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 2) ||
 307                                  !GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 3));
 308       GLbitfield mappingFlags = GL_MAP_WRITE_BIT;
 309
 310       if (masking)
 311          mappingFlags |= GL_MAP_READ_BIT;
 312
 313       /* Map color buffer */
 314       ctx->Driver.MapRenderbuffer(ctx, colorRb, xpos, ypos, width, height,
 315                                   mappingFlags, &colorMap, &colorRowStride,
 316                                   fb->FlipY);
 317       if (!colorMap) {
 318          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 319          continue;
 320       }
 321
 322       if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 323          const GLfloat scale = value / 32767.0f;
 324          GLint i, j;
 325          GLfloat (*rgba)[4], (*dest)[4];
 326
 327          rgba = malloc(width * 4 * sizeof(GLfloat));
 328          dest = malloc(width * 4 * sizeof(GLfloat));
 329
 330          if (rgba && dest) {
 331             for (j = 0; j < height; j++) {
 332                GLshort *acc = (GLshort *) accMap;
 333
 334                for (i = 0; i < width; i++) {
 335                   rgba[i][0] = acc[i * 4 + 0] * scale;
 336                   rgba[i][1] = acc[i * 4 + 1] * scale;
 337                   rgba[i][2] = acc[i * 4 + 2] * scale;
 338                   rgba[i][3] = acc[i * 4 + 3] * scale;
 339                }
 340
 341                if (masking) {
 342
 343                   /* get existing colors from dest buffer */
 344                   _mesa_unpack_rgba_row(colorRb->Format, width, colorMap, dest);
 345
 346                   /* use the dest colors where mask[channel] = 0 */
 347                   if (!GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 0)) {
 348                      for (i = 0; i < width; i++)
 349                         rgba[i][RCOMP] = dest[i][RCOMP];
 350                   }
 351                   if (!GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 1)) {
 352                      for (i = 0; i < width; i++)
 353                         rgba[i][GCOMP] = dest[i][GCOMP];
 354                   }
 355                   if (!GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 2)) {
 356                      for (i = 0; i < width; i++)
 357                         rgba[i][BCOMP] = dest[i][BCOMP];
 358                   }
 359                   if (!GET_COLORMASK_BIT(ctx->Color.ColorMask, buffer, 3)) {
 360                      for (i = 0; i < width; i++)
 361                         rgba[i][ACOMP] = dest[i][ACOMP];
 362                   }
 363                }
 364
 365                _mesa_pack_float_rgba_row(colorRb->Format, width,
 366                                          (const GLfloat (*)[4]) rgba, colorMap);
 367
 368                accMap += accRowStride;
 369                colorMap += colorRowStride;
 370             }
 371          }
 372          else {
 373             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 374          }
 375          free(rgba);
 376          free(dest);
 377       }
 378       else {
 379          /* other types someday? */
 380       }
 381
 382       ctx->Driver.UnmapRenderbuffer(ctx, colorRb);
 383    }
 384
 385    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 386 }
 387
 388
 389
 390 /**
 391  * Software fallback for glAccum.  A hardware driver that supports
 392  * signed 16-bit color channels could implement hardware accumulation
 393  * operations, but no driver does so at this time.
 394  */
 395 static void
 396 accum(struct gl_context *ctx, GLenum op, GLfloat value)
 397 {
 398    GLint xpos, ypos, width, height;
 399
 400    if (!ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer) {
 401       _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer");
 402       return;
 403    }
 404
 405    if (!_mesa_check_conditional_render(ctx))
 406       return;
 407
 408    _mesa_update_draw_buffer_bounds(ctx, ctx->DrawBuffer);
 409
 410    xpos = ctx->DrawBuffer->_Xmin;
 411    ypos = ctx->DrawBuffer->_Ymin;
 412    width =  ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 413    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 414
 415    switch (op) {
 416    case GL_ADD:
 417       if (value != 0.0F) {
 418          accum_scale_or_bias(ctx, value, xpos, ypos, width, height, GL_TRUE);
 419       }
 420       break;
 421    case GL_MULT:
 422       if (value != 1.0F) {
 423          accum_scale_or_bias(ctx, value, xpos, ypos, width, height, GL_FALSE);
 424       }
 425       break;
 426    case GL_ACCUM:
 427       if (value != 0.0F) {
 428          accum_or_load(ctx, value, xpos, ypos, width, height, GL_FALSE);
 429       }
 430       break;
 431    case GL_LOAD:
 432       accum_or_load(ctx, value, xpos, ypos, width, height, GL_TRUE);
 433       break;
 434    case GL_RETURN:
 435       accum_return(ctx, value, xpos, ypos, width, height);
 436       break;
 437    default:
 438       unreachable("invalid mode in _mesa_Accum()");
 439       break;
 440    }
 441 }
 442
 443
 444 void
 445 _mesa_init_accum( struct gl_context *ctx )
 446 {
 447    /* Accumulate buffer group */
 448    ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 449 }
 450
 451
 452 void GLAPIENTRY
 453 _mesa_Accum( GLenum op, GLfloat value )
 454 {
 455    GET_CURRENT_CONTEXT(ctx);
 456    FLUSH_VERTICES(ctx, 0);
 457
 458    switch (op) {
 459    case GL_ADD:
 460    case GL_MULT:
 461    case GL_ACCUM:
 462    case GL_LOAD:
 463    case GL_RETURN:
 464       /* OK */
 465       break;
 466    default:
 467       _mesa_error(ctx, GL_INVALID_ENUM, "glAccum(op)");
 468       return;
 469    }
 470
 471    if (ctx->DrawBuffer->Visual.accumRedBits == 0) {
 472       _mesa_error(ctx, GL_INVALID_OPERATION, "glAccum(no accum buffer)");
 473       return;
 474    }
 475
 476    if (ctx->DrawBuffer != ctx->ReadBuffer) {
 477       /* See GLX_SGI_make_current_read or WGL_ARB_make_current_read,
 478        * or GL_EXT_framebuffer_blit.
 479        */
 480       _mesa_error(ctx, GL_INVALID_OPERATION,
 481                   "glAccum(different read/draw buffers)");
 482       return;
 483    }
 484
 485    if (ctx->NewState)
 486       _mesa_update_state(ctx);
 487
 488    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 489       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
 490                   "glAccum(incomplete framebuffer)");
 491       return;
 492    }
 493
 494    if (ctx->RasterDiscard)
 495       return;
 496
 497    if (ctx->RenderMode == GL_RENDER) {
 498       accum(ctx, op, value);
 499    }
 500 }