src/mesa/main/accum.c

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