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 #include "imports.h"
  33 #include "macros.h"
  34 #include "state.h"
  35 #include "mtypes.h"
  36 #include "main/dispatch.h"
  37
  38
  39 void GLAPIENTRY
  40 _mesa_ClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
  41 {
  42    GLfloat tmp[4];
  43    GET_CURRENT_CONTEXT(ctx);
  44
  45    tmp[0] = CLAMP( red,   -1.0F, 1.0F );
  46    tmp[1] = CLAMP( green, -1.0F, 1.0F );
  47    tmp[2] = CLAMP( blue,  -1.0F, 1.0F );
  48    tmp[3] = CLAMP( alpha, -1.0F, 1.0F );
  49
  50    if (TEST_EQ_4V(tmp, ctx->Accum.ClearColor))
  51       return;
  52
  53    COPY_4FV( ctx->Accum.ClearColor, tmp );
  54 }
  55
  56
  57 /**
  58  * Clear the accumulation buffer by mapping the renderbuffer and
  59  * writing the clear color to it.  Called by the driver's implementation
  60  * of the glClear function.
  61  */
  62 void
  63 _mesa_clear_accum_buffer(struct gl_context *ctx)
  64 {
  65    GLuint x, y, width, height;
  66    GLubyte *accMap;
  67    GLint accRowStride;
  68    struct gl_renderbuffer *accRb;
  69
  70    if (!ctx->DrawBuffer)
  71       return;
  72
  73    accRb = ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
  74    if (!accRb)
  75       return;   /* missing accum buffer, not an error */
  76
  77    _mesa_update_draw_buffer_bounds(ctx, ctx->DrawBuffer);
  78
  79    /* bounds, with scissor */
  80    x = ctx->DrawBuffer->_Xmin;
  81    y = ctx->DrawBuffer->_Ymin;
  82    width = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
  83    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
  84
  85    ctx->Driver.MapRenderbuffer(ctx, accRb, x, y, width, height,
  86                                GL_MAP_WRITE_BIT, &accMap, &accRowStride);
  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
 143    if (!accMap) {
 144       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 145       return;
 146    }
 147
 148    if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 149       const GLshort incr = (GLshort) (value * 32767.0f);
 150       GLint i, j;
 151       if (bias) {
 152          for (j = 0; j < height; j++) {
 153             GLshort *acc = (GLshort *) accMap;
 154             for (i = 0; i < 4 * width; i++) {
 155                acc[i] += incr;
 156             }
 157             accMap += accRowStride;
 158          }
 159       }
 160       else {
 161          /* scale */
 162          for (j = 0; j < height; j++) {
 163             GLshort *acc = (GLshort *) accMap;
 164             for (i = 0; i < 4 * width; i++) {
 165                acc[i] = (GLshort) (acc[i] * value);
 166             }
 167             accMap += accRowStride;
 168          }
 169       }
 170    }
 171    else {
 172       /* other types someday? */
 173    }
 174
 175    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 176 }
 177
 178
 179 /**
 180  * if (load)
 181  *    Accum = ColorBuf * value
 182  * else
 183  *    Accum += ColorBuf * value
 184  */
 185 static void
 186 accum_or_load(struct gl_context *ctx, GLfloat value,
 187               GLint xpos, GLint ypos, GLint width, GLint height,
 188               GLboolean load)
 189 {
 190    struct gl_renderbuffer *accRb =
 191       ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer;
 192    struct gl_renderbuffer *colorRb = ctx->ReadBuffer->_ColorReadBuffer;
 193    GLubyte *accMap, *colorMap;
 194    GLint accRowStride, colorRowStride;
 195    GLbitfield mappingFlags;
 196
 197    if (!colorRb) {
 198       /* no read buffer - OK */
 199       return;
 200    }
 201
 202    assert(accRb);
 203
 204    mappingFlags = GL_MAP_WRITE_BIT;
 205    if (!load) /* if we're accumulating */
 206       mappingFlags |= GL_MAP_READ_BIT;
 207
 208    /* Map accum buffer */
 209    ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,
 210                                mappingFlags, &accMap, &accRowStride);
 211    if (!accMap) {
 212       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 213       return;
 214    }
 215
 216    /* Map color buffer */
 217    ctx->Driver.MapRenderbuffer(ctx, colorRb, xpos, ypos, width, height,
 218                                GL_MAP_READ_BIT,
 219                                &colorMap, &colorRowStride);
 220    if (!colorMap) {
 221       ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 222       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 223       return;
 224    }
 225
 226    if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 227       const GLfloat scale = value * 32767.0f;
 228       GLint i, j;
 229       GLfloat (*rgba)[4];
 230
 231       rgba = malloc(width * 4 * sizeof(GLfloat));
 232       if (rgba) {
 233          for (j = 0; j < height; j++) {
 234             GLshort *acc = (GLshort *) accMap;
 235
 236             /* read colors from source color buffer */
 237             _mesa_unpack_rgba_row(colorRb->Format, width, colorMap, rgba);
 238
 239             if (load) {
 240                for (i = 0; i < width; i++) {
 241                   acc[i * 4 + 0] = (GLshort) (rgba[i][RCOMP] * scale);
 242                   acc[i * 4 + 1] = (GLshort) (rgba[i][GCOMP] * scale);
 243                   acc[i * 4 + 2] = (GLshort) (rgba[i][BCOMP] * scale);
 244                   acc[i * 4 + 3] = (GLshort) (rgba[i][ACOMP] * scale);
 245                }
 246             }
 247             else {
 248                /* accumulate */
 249                for (i = 0; i < width; i++) {
 250                   acc[i * 4 + 0] += (GLshort) (rgba[i][RCOMP] * scale);
 251                   acc[i * 4 + 1] += (GLshort) (rgba[i][GCOMP] * scale);
 252                   acc[i * 4 + 2] += (GLshort) (rgba[i][BCOMP] * scale);
 253                   acc[i * 4 + 3] += (GLshort) (rgba[i][ACOMP] * scale);
 254                }
 255             }
 256
 257             colorMap += colorRowStride;
 258             accMap += accRowStride;
 259          }
 260
 261          free(rgba);
 262       }
 263       else {
 264          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 265       }
 266    }
 267    else {
 268       /* other types someday? */
 269    }
 270
 271    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 272    ctx->Driver.UnmapRenderbuffer(ctx, colorRb);
 273 }
 274
 275
 276 /**
 277  * ColorBuffer = Accum * value
 278  */
 279 static void
 280 accum_return(struct gl_context *ctx, GLfloat value,
 281              GLint xpos, GLint ypos, GLint width, GLint height)
 282 {
 283    struct gl_framebuffer *fb = ctx->DrawBuffer;
 284    struct gl_renderbuffer *accRb = fb->Attachment[BUFFER_ACCUM].Renderbuffer;
 285    GLubyte *accMap, *colorMap;
 286    GLint accRowStride, colorRowStride;
 287    GLuint buffer;
 288
 289    /* Map accum buffer */
 290    ctx->Driver.MapRenderbuffer(ctx, accRb, xpos, ypos, width, height,
 291                                GL_MAP_READ_BIT,
 292                                &accMap, &accRowStride);
 293    if (!accMap) {
 294       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 295       return;
 296    }
 297
 298    /* Loop over destination buffers */
 299    for (buffer = 0; buffer < fb->_NumColorDrawBuffers; buffer++) {
 300       struct gl_renderbuffer *colorRb = fb->_ColorDrawBuffers[buffer];
 301       const GLboolean masking = (!ctx->Color.ColorMask[buffer][RCOMP] ||
 302                                  !ctx->Color.ColorMask[buffer][GCOMP] ||
 303                                  !ctx->Color.ColorMask[buffer][BCOMP] ||
 304                                  !ctx->Color.ColorMask[buffer][ACOMP]);
 305       GLbitfield mappingFlags = GL_MAP_WRITE_BIT;
 306
 307       if (masking)
 308          mappingFlags |= GL_MAP_READ_BIT;
 309
 310       /* Map color buffer */
 311       ctx->Driver.MapRenderbuffer(ctx, colorRb, xpos, ypos, width, height,
 312                                   mappingFlags, &colorMap, &colorRowStride);
 313       if (!colorMap) {
 314          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 315          continue;
 316       }
 317
 318       if (accRb->Format == MESA_FORMAT_RGBA_SNORM16) {
 319          const GLfloat scale = value / 32767.0f;
 320          GLint i, j;
 321          GLfloat (*rgba)[4], (*dest)[4];
 322
 323          rgba = malloc(width * 4 * sizeof(GLfloat));
 324          dest = malloc(width * 4 * sizeof(GLfloat));
 325
 326          if (rgba && dest) {
 327             for (j = 0; j < height; j++) {
 328                GLshort *acc = (GLshort *) accMap;
 329
 330                for (i = 0; i < width; i++) {
 331                   rgba[i][0] = acc[i * 4 + 0] * scale;
 332                   rgba[i][1] = acc[i * 4 + 1] * scale;
 333                   rgba[i][2] = acc[i * 4 + 2] * scale;
 334                   rgba[i][3] = acc[i * 4 + 3] * scale;
 335                }
 336
 337                if (masking) {
 338
 339                   /* get existing colors from dest buffer */
 340                   _mesa_unpack_rgba_row(colorRb->Format, width, colorMap, dest);
 341
 342                   /* use the dest colors where mask[channel] = 0 */
 343                   if (ctx->Color.ColorMask[buffer][RCOMP] == 0) {
 344                      for (i = 0; i < width; i++)
 345                         rgba[i][RCOMP] = dest[i][RCOMP];
 346                   }
 347                   if (ctx->Color.ColorMask[buffer][GCOMP] == 0) {
 348                      for (i = 0; i < width; i++)
 349                         rgba[i][GCOMP] = dest[i][GCOMP];
 350                   }
 351                   if (ctx->Color.ColorMask[buffer][BCOMP] == 0) {
 352                      for (i = 0; i < width; i++)
 353                         rgba[i][BCOMP] = dest[i][BCOMP];
 354                   }
 355                   if (ctx->Color.ColorMask[buffer][ACOMP] == 0) {
 356                      for (i = 0; i < width; i++)
 357                         rgba[i][ACOMP] = dest[i][ACOMP];
 358                   }
 359                }
 360
 361                _mesa_pack_float_rgba_row(colorRb->Format, width,
 362                                          (const GLfloat (*)[4]) rgba, colorMap);
 363
 364                accMap += accRowStride;
 365                colorMap += colorRowStride;
 366             }
 367          }
 368          else {
 369             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAccum");
 370          }
 371          free(rgba);
 372          free(dest);
 373       }
 374       else {
 375          /* other types someday? */
 376       }
 377
 378       ctx->Driver.UnmapRenderbuffer(ctx, colorRb);
 379    }
 380
 381    ctx->Driver.UnmapRenderbuffer(ctx, accRb);
 382 }
 383
 384
 385
 386 /**
 387  * Software fallback for glAccum.  A hardware driver that supports
 388  * signed 16-bit color channels could implement hardware accumulation
 389  * operations, but no driver does so at this time.
 390  */
 391 static void
 392 accum(struct gl_context *ctx, GLenum op, GLfloat value)
 393 {
 394    GLint xpos, ypos, width, height;
 395
 396    if (!ctx->DrawBuffer->Attachment[BUFFER_ACCUM].Renderbuffer) {
 397       _mesa_warning(ctx, "Calling glAccum() without an accumulation buffer");
 398       return;
 399    }
 400
 401    if (!_mesa_check_conditional_render(ctx))
 402       return;
 403
 404    _mesa_update_draw_buffer_bounds(ctx, ctx->DrawBuffer);
 405
 406    xpos = ctx->DrawBuffer->_Xmin;
 407    ypos = ctx->DrawBuffer->_Ymin;
 408    width =  ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
 409    height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
 410
 411    switch (op) {
 412    case GL_ADD:
 413       if (value != 0.0F) {
 414          accum_scale_or_bias(ctx, value, xpos, ypos, width, height, GL_TRUE);
 415       }
 416       break;
 417    case GL_MULT:
 418       if (value != 1.0F) {
 419          accum_scale_or_bias(ctx, value, xpos, ypos, width, height, GL_FALSE);
 420       }
 421       break;
 422    case GL_ACCUM:
 423       if (value != 0.0F) {
 424          accum_or_load(ctx, value, xpos, ypos, width, height, GL_FALSE);
 425       }
 426       break;
 427    case GL_LOAD:
 428       accum_or_load(ctx, value, xpos, ypos, width, height, GL_TRUE);
 429       break;
 430    case GL_RETURN:
 431       accum_return(ctx, value, xpos, ypos, width, height);
 432       break;
 433    default:
 434       unreachable("invalid mode in _mesa_Accum()");
 435       break;
 436    }
 437 }
 438
 439
 440 void
 441 _mesa_init_accum( struct gl_context *ctx )
 442 {
 443    /* Accumulate buffer group */
 444    ASSIGN_4V( ctx->Accum.ClearColor, 0.0, 0.0, 0.0, 0.0 );
 445 }
 446
 447
 448 void GLAPIENTRY
 449 _mesa_Accum( GLenum op, GLfloat value )
 450 {
 451    GET_CURRENT_CONTEXT(ctx);
 452    FLUSH_VERTICES(ctx, 0);
 453
 454    switch (op) {
 455    case GL_ADD:
 456    case GL_MULT:
 457    case GL_ACCUM:
 458    case GL_LOAD:
 459    case GL_RETURN:
 460       /* OK */
 461       break;
 462    default:
 463       _mesa_error(ctx, GL_INVALID_ENUM, "glAccum(op)");
 464       return;
 465    }
 466
 467    if (ctx->DrawBuffer->Visual.haveAccumBuffer == 0) {
 468       _mesa_error(ctx, GL_INVALID_OPERATION, "glAccum(no accum buffer)");
 469       return;
 470    }
 471
 472    if (ctx->DrawBuffer != ctx->ReadBuffer) {
 473       /* See GLX_SGI_make_current_read or WGL_ARB_make_current_read,
 474        * or GL_EXT_framebuffer_blit.
 475        */
 476       _mesa_error(ctx, GL_INVALID_OPERATION,
 477                   "glAccum(different read/draw buffers)");
 478       return;
 479    }
 480
 481    if (ctx->NewState)
 482       _mesa_update_state(ctx);
 483
 484    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 485       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
 486                   "glAccum(incomplete framebuffer)");
 487       return;
 488    }
 489
 490    if (ctx->RasterDiscard)
 491       return;
 492
 493    if (ctx->RenderMode == GL_RENDER) {
 494       accum(ctx, op, value);
 495    }
 496 }