src/mesa/main/blend.c

   1 /**
   2  * \file blend.c
   3  * Blending operations.
   4  */
   5
   6 /*
   7  * Mesa 3-D graphics library
   8  * Version:  6.5.1
   9  *
  10  * Copyright (C) 1999-2006  Brian Paul   All Rights Reserved.
  11  *
  12  * Permission is hereby granted, free of charge, to any person obtaining a
  13  * copy of this software and associated documentation files (the "Software"),
  14  * to deal in the Software without restriction, including without limitation
  15  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  16  * and/or sell copies of the Software, and to permit persons to whom the
  17  * Software is furnished to do so, subject to the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be included
  20  * in all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  23  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  25  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  26  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28  */
  29
  30
  31
  32 #include "glheader.h"
  33 #include "blend.h"
  34 #include "context.h"
  35 #include "enums.h"
  36 #include "macros.h"
  37 #include "mtypes.h"
  38
  39
  40
  41 /**
  42  * Check if given blend source factor is legal.
  43  * \return GL_TRUE if legal, GL_FALSE otherwise.
  44  */
  45 static GLboolean
  46 legal_src_factor(const struct gl_context *ctx, GLenum factor)
  47 {
  48    switch (factor) {
  49    case GL_SRC_COLOR:
  50    case GL_ONE_MINUS_SRC_COLOR:
  51       return ctx->Extensions.NV_blend_square;
  52    case GL_ZERO:
  53    case GL_ONE:
  54    case GL_DST_COLOR:
  55    case GL_ONE_MINUS_DST_COLOR:
  56    case GL_SRC_ALPHA:
  57    case GL_ONE_MINUS_SRC_ALPHA:
  58    case GL_DST_ALPHA:
  59    case GL_ONE_MINUS_DST_ALPHA:
  60    case GL_SRC_ALPHA_SATURATE:
  61    case GL_CONSTANT_COLOR:
  62    case GL_ONE_MINUS_CONSTANT_COLOR:
  63    case GL_CONSTANT_ALPHA:
  64    case GL_ONE_MINUS_CONSTANT_ALPHA:
  65       return GL_TRUE;
  66    default:
  67       return GL_FALSE;
  68    }
  69 }
  70
  71
  72 /**
  73  * Check if given blend destination factor is legal.
  74  * \return GL_TRUE if legal, GL_FALSE otherwise.
  75  */
  76 static GLboolean
  77 legal_dst_factor(const struct gl_context *ctx, GLenum factor)
  78 {
  79    switch (factor) {
  80    case GL_DST_COLOR:
  81    case GL_ONE_MINUS_DST_COLOR:
  82       return ctx->Extensions.NV_blend_square;
  83    case GL_ZERO:
  84    case GL_ONE:
  85    case GL_SRC_COLOR:
  86    case GL_ONE_MINUS_SRC_COLOR:
  87    case GL_SRC_ALPHA:
  88    case GL_ONE_MINUS_SRC_ALPHA:
  89    case GL_DST_ALPHA:
  90    case GL_ONE_MINUS_DST_ALPHA:
  91    case GL_CONSTANT_COLOR:
  92    case GL_ONE_MINUS_CONSTANT_COLOR:
  93    case GL_CONSTANT_ALPHA:
  94    case GL_ONE_MINUS_CONSTANT_ALPHA:
  95       return GL_TRUE;
  96    default:
  97       return GL_FALSE;
  98    }
  99 }
 100
 101
 102 /**
 103  * Check if src/dest RGB/A blend factors are legal.  If not generate
 104  * a GL error.
 105  * \return GL_TRUE if factors are legal, GL_FALSE otherwise.
 106  */
 107 static GLboolean
 108 validate_blend_factors(struct gl_context *ctx, const char *func,
 109                        GLenum sfactorRGB, GLenum dfactorRGB,
 110                        GLenum sfactorA, GLenum dfactorA)
 111 {
 112    if (!legal_src_factor(ctx, sfactorRGB)) {
 113       _mesa_error(ctx, GL_INVALID_ENUM,
 114                   "%s(sfactorRGB = %s)", func,
 115                   _mesa_lookup_enum_by_nr(sfactorRGB));
 116       return GL_FALSE;
 117    }
 118
 119    if (!legal_dst_factor(ctx, dfactorRGB)) {
 120       _mesa_error(ctx, GL_INVALID_ENUM,
 121                   "%s(dfactorRGB = %s)", func,
 122                   _mesa_lookup_enum_by_nr(dfactorRGB));
 123       return GL_FALSE;
 124    }
 125
 126    if (sfactorA != sfactorRGB && !legal_src_factor(ctx, sfactorA)) {
 127       _mesa_error(ctx, GL_INVALID_ENUM,
 128                   "%s(sfactorA = %s)", func,
 129                   _mesa_lookup_enum_by_nr(sfactorA));
 130       return GL_FALSE;
 131    }
 132
 133    if (dfactorA != dfactorRGB && !legal_dst_factor(ctx, dfactorA)) {
 134       _mesa_error(ctx, GL_INVALID_ENUM,
 135                   "%s(dfactorA = %s)", func,
 136                   _mesa_lookup_enum_by_nr(dfactorA));
 137       return GL_FALSE;
 138    }
 139
 140    return GL_TRUE;
 141 }
 142
 143
 144 /**
 145  * Specify the blending operation.
 146  *
 147  * \param sfactor source factor operator.
 148  * \param dfactor destination factor operator.
 149  *
 150  * \sa glBlendFunc, glBlendFuncSeparateEXT
 151  */
 152 void GLAPIENTRY
 153 _mesa_BlendFunc( GLenum sfactor, GLenum dfactor )
 154 {
 155    _mesa_BlendFuncSeparateEXT(sfactor, dfactor, sfactor, dfactor);
 156 }
 157
 158
 159 /**
 160  * Set the separate blend source/dest factors for all draw buffers.
 161  *
 162  * \param sfactorRGB RGB source factor operator.
 163  * \param dfactorRGB RGB destination factor operator.
 164  * \param sfactorA alpha source factor operator.
 165  * \param dfactorA alpha destination factor operator.
 166  */
 167 void GLAPIENTRY
 168 _mesa_BlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB,
 169                             GLenum sfactorA, GLenum dfactorA )
 170 {
 171    GLuint buf, numBuffers;
 172    GLboolean changed;
 173    GET_CURRENT_CONTEXT(ctx);
 174    ASSERT_OUTSIDE_BEGIN_END(ctx);
 175
 176    if (MESA_VERBOSE & VERBOSE_API)
 177       _mesa_debug(ctx, "glBlendFuncSeparate %s %s %s %s\n",
 178                   _mesa_lookup_enum_by_nr(sfactorRGB),
 179                   _mesa_lookup_enum_by_nr(dfactorRGB),
 180                   _mesa_lookup_enum_by_nr(sfactorA),
 181                   _mesa_lookup_enum_by_nr(dfactorA));
 182
 183    if (!validate_blend_factors(ctx, "glBlendFuncSeparate",
 184                                sfactorRGB, dfactorRGB,
 185                                sfactorA, dfactorA)) {
 186       return;
 187    }
 188
 189    numBuffers = ctx->Extensions.ARB_draw_buffers_blend
 190       ? ctx->Const.MaxDrawBuffers : 1;
 191
 192    changed = GL_FALSE;
 193    for (buf = 0; buf < numBuffers; buf++) {
 194       if (ctx->Color.Blend[buf].SrcRGB != sfactorRGB ||
 195           ctx->Color.Blend[buf].DstRGB != dfactorRGB ||
 196           ctx->Color.Blend[buf].SrcA != sfactorA ||
 197           ctx->Color.Blend[buf].DstA != dfactorA) {
 198          changed = GL_TRUE;
 199          break;
 200       }
 201    }
 202    if (!changed)
 203       return;
 204
 205    FLUSH_VERTICES(ctx, _NEW_COLOR);
 206
 207    for (buf = 0; buf < numBuffers; buf++) {
 208       ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
 209       ctx->Color.Blend[buf].DstRGB = dfactorRGB;
 210       ctx->Color.Blend[buf].SrcA = sfactorA;
 211       ctx->Color.Blend[buf].DstA = dfactorA;
 212    }
 213    ctx->Color._BlendFuncPerBuffer = GL_FALSE;
 214
 215    if (ctx->Driver.BlendFuncSeparate) {
 216       ctx->Driver.BlendFuncSeparate(ctx, sfactorRGB, dfactorRGB,
 217                                     sfactorA, dfactorA);
 218    }
 219 }
 220
 221
 222 #if _HAVE_FULL_GL
 223
 224
 225 /**
 226  * Set blend source/dest factors for one color buffer/target.
 227  */
 228 void GLAPIENTRY
 229 _mesa_BlendFunci(GLuint buf, GLenum sfactor, GLenum dfactor)
 230 {
 231    _mesa_BlendFuncSeparatei(buf, sfactor, dfactor, sfactor, dfactor);
 232 }
 233
 234
 235 /**
 236  * Set separate blend source/dest factors for one color buffer/target.
 237  */
 238 void GLAPIENTRY
 239 _mesa_BlendFuncSeparatei(GLuint buf, GLenum sfactorRGB, GLenum dfactorRGB,
 240                          GLenum sfactorA, GLenum dfactorA)
 241 {
 242    GET_CURRENT_CONTEXT(ctx);
 243    ASSERT_OUTSIDE_BEGIN_END(ctx);
 244
 245    if (!ctx->Extensions.ARB_draw_buffers_blend) {
 246       _mesa_error(ctx, GL_INVALID_OPERATION, "glBlendFunc[Separate]i()");
 247       return;
 248    }
 249
 250    if (buf >= ctx->Const.MaxDrawBuffers) {
 251       _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
 252                   buf);
 253       return;
 254    }
 255
 256    if (!validate_blend_factors(ctx, "glBlendFuncSeparatei",
 257                                sfactorRGB, dfactorRGB,
 258                                sfactorA, dfactorA)) {
 259       return;
 260    }
 261
 262    if (ctx->Color.Blend[buf].SrcRGB == sfactorRGB &&
 263        ctx->Color.Blend[buf].DstRGB == dfactorRGB &&
 264        ctx->Color.Blend[buf].SrcA == sfactorA &&
 265        ctx->Color.Blend[buf].DstA == dfactorA)
 266       return; /* no change */
 267
 268    FLUSH_VERTICES(ctx, _NEW_COLOR);
 269
 270    ctx->Color.Blend[buf].SrcRGB = sfactorRGB;
 271    ctx->Color.Blend[buf].DstRGB = dfactorRGB;
 272    ctx->Color.Blend[buf].SrcA = sfactorA;
 273    ctx->Color.Blend[buf].DstA = dfactorA;
 274    ctx->Color._BlendFuncPerBuffer = GL_TRUE;
 275
 276    if (ctx->Driver.BlendFuncSeparatei) {
 277       ctx->Driver.BlendFuncSeparatei(ctx, buf, sfactorRGB, dfactorRGB,
 278                                      sfactorA, dfactorA);
 279    }
 280 }
 281
 282
 283 /**
 284  * Check if given blend equation is legal.
 285  * \return GL_TRUE if legal, GL_FALSE otherwise.
 286  */
 287 static GLboolean
 288 legal_blend_equation(const struct gl_context *ctx,
 289                      GLenum mode, GLboolean is_separate)
 290 {
 291    switch (mode) {
 292    case GL_FUNC_ADD:
 293       return GL_TRUE;
 294    case GL_MIN:
 295    case GL_MAX:
 296       return ctx->Extensions.EXT_blend_minmax;
 297    case GL_LOGIC_OP:
 298       /* glBlendEquationSeparate cannot take GL_LOGIC_OP as a parameter.
 299        */
 300       return ctx->Extensions.EXT_blend_logic_op && !is_separate;
 301    case GL_FUNC_SUBTRACT:
 302    case GL_FUNC_REVERSE_SUBTRACT:
 303       return ctx->Extensions.EXT_blend_subtract;
 304    default:
 305       return GL_FALSE;
 306    }
 307 }
 308
 309
 310 /* This is really an extension function! */
 311 void GLAPIENTRY
 312 _mesa_BlendEquation( GLenum mode )
 313 {
 314    GLuint buf, numBuffers;
 315    GLboolean changed;
 316    GET_CURRENT_CONTEXT(ctx);
 317    ASSERT_OUTSIDE_BEGIN_END(ctx);
 318
 319    if (MESA_VERBOSE & VERBOSE_API)
 320       _mesa_debug(ctx, "glBlendEquation(%s)\n",
 321                   _mesa_lookup_enum_by_nr(mode));
 322
 323    if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
 324       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquation");
 325       return;
 326    }
 327
 328    numBuffers = ctx->Extensions.ARB_draw_buffers_blend
 329       ? ctx->Const.MaxDrawBuffers : 1;
 330
 331    changed = GL_FALSE;
 332    for (buf = 0; buf < numBuffers; buf++) {
 333       if (ctx->Color.Blend[buf].EquationRGB != mode ||
 334           ctx->Color.Blend[buf].EquationA != mode) {
 335          changed = GL_TRUE;
 336          break;
 337       }
 338    }
 339    if (!changed)
 340       return;
 341
 342    FLUSH_VERTICES(ctx, _NEW_COLOR);
 343    for (buf = 0; buf < numBuffers; buf++) {
 344       ctx->Color.Blend[buf].EquationRGB = mode;
 345       ctx->Color.Blend[buf].EquationA = mode;
 346    }
 347    ctx->Color._BlendEquationPerBuffer = GL_FALSE;
 348
 349    if (ctx->Driver.BlendEquationSeparate)
 350       (*ctx->Driver.BlendEquationSeparate)( ctx, mode, mode );
 351 }
 352
 353
 354 /**
 355  * Set blend equation for one color buffer/target.
 356  */
 357 void GLAPIENTRY
 358 _mesa_BlendEquationi(GLuint buf, GLenum mode)
 359 {
 360    GET_CURRENT_CONTEXT(ctx);
 361    ASSERT_OUTSIDE_BEGIN_END(ctx);
 362
 363    if (MESA_VERBOSE & VERBOSE_API)
 364       _mesa_debug(ctx, "glBlendEquationi(%u, %s)\n",
 365                   buf, _mesa_lookup_enum_by_nr(mode));
 366
 367    if (buf >= ctx->Const.MaxDrawBuffers) {
 368       _mesa_error(ctx, GL_INVALID_VALUE, "glBlendFuncSeparatei(buffer=%u)",
 369                   buf);
 370       return;
 371    }
 372
 373    if (!legal_blend_equation(ctx, mode, GL_FALSE)) {
 374       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationi");
 375       return;
 376    }
 377
 378    if (ctx->Color.Blend[buf].EquationRGB == mode &&
 379        ctx->Color.Blend[buf].EquationA == mode)
 380       return;  /* no change */
 381
 382    FLUSH_VERTICES(ctx, _NEW_COLOR);
 383    ctx->Color.Blend[buf].EquationRGB = mode;
 384    ctx->Color.Blend[buf].EquationA = mode;
 385    ctx->Color._BlendEquationPerBuffer = GL_TRUE;
 386
 387    if (ctx->Driver.BlendEquationSeparatei)
 388       ctx->Driver.BlendEquationSeparatei(ctx, buf, mode, mode);
 389 }
 390
 391
 392 void GLAPIENTRY
 393 _mesa_BlendEquationSeparateEXT( GLenum modeRGB, GLenum modeA )
 394 {
 395    GLuint buf, numBuffers;
 396    GLboolean changed;
 397    GET_CURRENT_CONTEXT(ctx);
 398    ASSERT_OUTSIDE_BEGIN_END(ctx);
 399
 400    if (MESA_VERBOSE & VERBOSE_API)
 401       _mesa_debug(ctx, "glBlendEquationSeparateEXT(%s %s)\n",
 402                   _mesa_lookup_enum_by_nr(modeRGB),
 403                   _mesa_lookup_enum_by_nr(modeA));
 404
 405    if ( (modeRGB != modeA) && !ctx->Extensions.EXT_blend_equation_separate ) {
 406       _mesa_error(ctx, GL_INVALID_OPERATION,
 407                   "glBlendEquationSeparateEXT not supported by driver");
 408       return;
 409    }
 410
 411    if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
 412       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeRGB)");
 413       return;
 414    }
 415
 416    if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
 417       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparateEXT(modeA)");
 418       return;
 419    }
 420
 421    numBuffers = ctx->Extensions.ARB_draw_buffers_blend
 422       ? ctx->Const.MaxDrawBuffers : 1;
 423
 424    changed = GL_FALSE;
 425    for (buf = 0; buf < numBuffers; buf++) {
 426       if (ctx->Color.Blend[buf].EquationRGB != modeRGB ||
 427           ctx->Color.Blend[buf].EquationA != modeA) {
 428          changed = GL_TRUE;
 429          break;
 430       }
 431    }
 432    if (!changed)
 433       return;
 434
 435    FLUSH_VERTICES(ctx, _NEW_COLOR);
 436    for (buf = 0; buf < numBuffers; buf++) {
 437       ctx->Color.Blend[buf].EquationRGB = modeRGB;
 438       ctx->Color.Blend[buf].EquationA = modeA;
 439    }
 440    ctx->Color._BlendEquationPerBuffer = GL_FALSE;
 441
 442    if (ctx->Driver.BlendEquationSeparate)
 443       ctx->Driver.BlendEquationSeparate(ctx, modeRGB, modeA);
 444 }
 445
 446
 447 /**
 448  * Set separate blend equations for one color buffer/target.
 449  */
 450 void
 451 _mesa_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeA)
 452 {
 453    GET_CURRENT_CONTEXT(ctx);
 454    ASSERT_OUTSIDE_BEGIN_END(ctx);
 455
 456    if (MESA_VERBOSE & VERBOSE_API)
 457       _mesa_debug(ctx, "glBlendEquationSeparatei(%u, %s %s)\n", buf,
 458                   _mesa_lookup_enum_by_nr(modeRGB),
 459                   _mesa_lookup_enum_by_nr(modeA));
 460
 461    if (buf >= ctx->Const.MaxDrawBuffers) {
 462       _mesa_error(ctx, GL_INVALID_VALUE, "glBlendEquationSeparatei(buffer=%u)",
 463                   buf);
 464       return;
 465    }
 466
 467    if (!legal_blend_equation(ctx, modeRGB, GL_TRUE)) {
 468       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeRGB)");
 469       return;
 470    }
 471
 472    if (!legal_blend_equation(ctx, modeA, GL_TRUE)) {
 473       _mesa_error(ctx, GL_INVALID_ENUM, "glBlendEquationSeparatei(modeA)");
 474       return;
 475    }
 476
 477    if (ctx->Color.Blend[buf].EquationRGB == modeRGB &&
 478        ctx->Color.Blend[buf].EquationA == modeA)
 479       return;  /* no change */
 480
 481    FLUSH_VERTICES(ctx, _NEW_COLOR);
 482    ctx->Color.Blend[buf].EquationRGB = modeRGB;
 483    ctx->Color.Blend[buf].EquationA = modeA;
 484    ctx->Color._BlendEquationPerBuffer = GL_TRUE;
 485
 486    if (ctx->Driver.BlendEquationSeparatei)
 487       ctx->Driver.BlendEquationSeparatei(ctx, buf, modeRGB, modeA);
 488 }
 489
 490
 491
 492 #endif /* _HAVE_FULL_GL */
 493
 494
 495 /**
 496  * Set the blending color.
 497  *
 498  * \param red red color component.
 499  * \param green green color component.
 500  * \param blue blue color component.
 501  * \param alpha alpha color component.
 502  *
 503  * \sa glBlendColor().
 504  *
 505  * Clamps the parameters and updates gl_colorbuffer_attrib::BlendColor.  On a
 506  * change, flushes the vertices and notifies the driver via
 507  * dd_function_table::BlendColor callback.
 508  */
 509 void GLAPIENTRY
 510 _mesa_BlendColor( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha )
 511 {
 512    GLfloat tmp[4];
 513    GET_CURRENT_CONTEXT(ctx);
 514    ASSERT_OUTSIDE_BEGIN_END(ctx);
 515
 516    tmp[0] = red;
 517    tmp[1] = green;
 518    tmp[2] = blue;
 519    tmp[3] = alpha;
 520
 521    if (TEST_EQ_4V(tmp, ctx->Color.BlendColorUnclamped))
 522       return;
 523
 524    FLUSH_VERTICES(ctx, _NEW_COLOR);
 525    COPY_4FV( ctx->Color.BlendColorUnclamped, tmp );
 526
 527    ctx->Color.BlendColor[0] = CLAMP(tmp[0], 0.0F, 1.0F);
 528    ctx->Color.BlendColor[1] = CLAMP(tmp[1], 0.0F, 1.0F);
 529    ctx->Color.BlendColor[2] = CLAMP(tmp[2], 0.0F, 1.0F);
 530    ctx->Color.BlendColor[3] = CLAMP(tmp[3], 0.0F, 1.0F);
 531
 532    if (ctx->Driver.BlendColor)
 533       (*ctx->Driver.BlendColor)(ctx, ctx->Color.BlendColor);
 534 }
 535
 536
 537 /**
 538  * Specify the alpha test function.
 539  *
 540  * \param func alpha comparison function.
 541  * \param ref reference value.
 542  *
 543  * Verifies the parameters and updates gl_colorbuffer_attrib.
 544  * On a change, flushes the vertices and notifies the driver via
 545  * dd_function_table::AlphaFunc callback.
 546  */
 547 void GLAPIENTRY
 548 _mesa_AlphaFunc( GLenum func, GLclampf ref )
 549 {
 550    GET_CURRENT_CONTEXT(ctx);
 551    ASSERT_OUTSIDE_BEGIN_END(ctx);
 552
 553    if (MESA_VERBOSE & VERBOSE_API)
 554       _mesa_debug(ctx, "glAlphaFunc(%s, %f)\n",
 555                   _mesa_lookup_enum_by_nr(func), ref);
 556
 557    switch (func) {
 558    case GL_NEVER:
 559    case GL_LESS:
 560    case GL_EQUAL:
 561    case GL_LEQUAL:
 562    case GL_GREATER:
 563    case GL_NOTEQUAL:
 564    case GL_GEQUAL:
 565    case GL_ALWAYS:
 566       if (ctx->Color.AlphaFunc == func && ctx->Color.AlphaRefUnclamped == ref)
 567          return; /* no change */
 568
 569       FLUSH_VERTICES(ctx, _NEW_COLOR);
 570       ctx->Color.AlphaFunc = func;
 571       ctx->Color.AlphaRefUnclamped = ref;
 572       ctx->Color.AlphaRef = CLAMP(ref, 0.0F, 1.0F);
 573
 574       if (ctx->Driver.AlphaFunc)
 575          ctx->Driver.AlphaFunc(ctx, func, ctx->Color.AlphaRef);
 576       return;
 577
 578    default:
 579       _mesa_error( ctx, GL_INVALID_ENUM, "glAlphaFunc(func)" );
 580       return;
 581    }
 582 }
 583
 584
 585 /**
 586  * Specify a logic pixel operation for color index rendering.
 587  *
 588  * \param opcode operation.
 589  *
 590  * Verifies that \p opcode is a valid enum and updates
 591 gl_colorbuffer_attrib::LogicOp.
 592  * On a change, flushes the vertices and notifies the driver via the
 593  * dd_function_table::LogicOpcode callback.
 594  */
 595 void GLAPIENTRY
 596 _mesa_LogicOp( GLenum opcode )
 597 {
 598    GET_CURRENT_CONTEXT(ctx);
 599    ASSERT_OUTSIDE_BEGIN_END(ctx);
 600
 601    if (MESA_VERBOSE & VERBOSE_API)
 602       _mesa_debug(ctx, "glLogicOp(%s)\n", _mesa_lookup_enum_by_nr(opcode));
 603
 604    switch (opcode) {
 605       case GL_CLEAR:
 606       case GL_SET:
 607       case GL_COPY:
 608       case GL_COPY_INVERTED:
 609       case GL_NOOP:
 610       case GL_INVERT:
 611       case GL_AND:
 612       case GL_NAND:
 613       case GL_OR:
 614       case GL_NOR:
 615       case GL_XOR:
 616       case GL_EQUIV:
 617       case GL_AND_REVERSE:
 618       case GL_AND_INVERTED:
 619       case GL_OR_REVERSE:
 620       case GL_OR_INVERTED:
 621          break;
 622       default:
 623          _mesa_error( ctx, GL_INVALID_ENUM, "glLogicOp" );
 624          return;
 625    }
 626
 627    if (ctx->Color.LogicOp == opcode)
 628       return;
 629
 630    FLUSH_VERTICES(ctx, _NEW_COLOR);
 631    ctx->Color.LogicOp = opcode;
 632
 633    if (ctx->Driver.LogicOpcode)
 634       ctx->Driver.LogicOpcode( ctx, opcode );
 635 }
 636
 637 #if _HAVE_FULL_GL
 638 void GLAPIENTRY
 639 _mesa_IndexMask( GLuint mask )
 640 {
 641    GET_CURRENT_CONTEXT(ctx);
 642    ASSERT_OUTSIDE_BEGIN_END(ctx);
 643
 644    if (ctx->Color.IndexMask == mask)
 645       return;
 646
 647    FLUSH_VERTICES(ctx, _NEW_COLOR);
 648    ctx->Color.IndexMask = mask;
 649 }
 650 #endif
 651
 652
 653 /**
 654  * Enable or disable writing of frame buffer color components.
 655  *
 656  * \param red whether to mask writing of the red color component.
 657  * \param green whether to mask writing of the green color component.
 658  * \param blue whether to mask writing of the blue color component.
 659  * \param alpha whether to mask writing of the alpha color component.
 660  *
 661  * \sa glColorMask().
 662  *
 663  * Sets the appropriate value of gl_colorbuffer_attrib::ColorMask.  On a
 664  * change, flushes the vertices and notifies the driver via the
 665  * dd_function_table::ColorMask callback.
 666  */
 667 void GLAPIENTRY
 668 _mesa_ColorMask( GLboolean red, GLboolean green,
 669                  GLboolean blue, GLboolean alpha )
 670 {
 671    GET_CURRENT_CONTEXT(ctx);
 672    GLubyte tmp[4];
 673    GLuint i;
 674    GLboolean flushed;
 675    ASSERT_OUTSIDE_BEGIN_END(ctx);
 676
 677    if (MESA_VERBOSE & VERBOSE_API)
 678       _mesa_debug(ctx, "glColorMask(%d, %d, %d, %d)\n",
 679                   red, green, blue, alpha);
 680
 681    /* Shouldn't have any information about channel depth in core mesa
 682     * -- should probably store these as the native booleans:
 683     */
 684    tmp[RCOMP] = red    ? 0xff : 0x0;
 685    tmp[GCOMP] = green  ? 0xff : 0x0;
 686    tmp[BCOMP] = blue   ? 0xff : 0x0;
 687    tmp[ACOMP] = alpha  ? 0xff : 0x0;
 688
 689    flushed = GL_FALSE;
 690    for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 691       if (!TEST_EQ_4V(tmp, ctx->Color.ColorMask[i])) {
 692          if (!flushed) {
 693             FLUSH_VERTICES(ctx, _NEW_COLOR);
 694          }
 695          flushed = GL_TRUE;
 696          COPY_4UBV(ctx->Color.ColorMask[i], tmp);
 697       }
 698    }
 699
 700    if (ctx->Driver.ColorMask)
 701       ctx->Driver.ColorMask( ctx, red, green, blue, alpha );
 702 }
 703
 704
 705 /**
 706  * For GL_EXT_draw_buffers2 and GL3
 707  */
 708 void GLAPIENTRY
 709 _mesa_ColorMaskIndexed( GLuint buf, GLboolean red, GLboolean green,
 710                         GLboolean blue, GLboolean alpha )
 711 {
 712    GLubyte tmp[4];
 713    GET_CURRENT_CONTEXT(ctx);
 714    ASSERT_OUTSIDE_BEGIN_END(ctx);
 715
 716    if (MESA_VERBOSE & VERBOSE_API)
 717       _mesa_debug(ctx, "glColorMaskIndexed %u %d %d %d %d\n",
 718                   buf, red, green, blue, alpha);
 719
 720    if (buf >= ctx->Const.MaxDrawBuffers) {
 721       _mesa_error(ctx, GL_INVALID_VALUE, "glColorMaskIndexed(buf=%u)", buf);
 722       return;
 723    }
 724
 725    /* Shouldn't have any information about channel depth in core mesa
 726     * -- should probably store these as the native booleans:
 727     */
 728    tmp[RCOMP] = red    ? 0xff : 0x0;
 729    tmp[GCOMP] = green  ? 0xff : 0x0;
 730    tmp[BCOMP] = blue   ? 0xff : 0x0;
 731    tmp[ACOMP] = alpha  ? 0xff : 0x0;
 732
 733    if (TEST_EQ_4V(tmp, ctx->Color.ColorMask[buf]))
 734       return;
 735
 736    FLUSH_VERTICES(ctx, _NEW_COLOR);
 737    COPY_4UBV(ctx->Color.ColorMask[buf], tmp);
 738
 739    if (ctx->Driver.ColorMaskIndexed)
 740       ctx->Driver.ColorMaskIndexed(ctx, buf, red, green, blue, alpha);
 741 }
 742
 743
 744 void GLAPIENTRY
 745 _mesa_ClampColorARB(GLenum target, GLenum clamp)
 746 {
 747    GET_CURRENT_CONTEXT(ctx);
 748
 749    ASSERT_OUTSIDE_BEGIN_END(ctx);
 750
 751    if (clamp != GL_TRUE && clamp != GL_FALSE && clamp != GL_FIXED_ONLY_ARB) {
 752       _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(clamp)");
 753       return;
 754    }
 755
 756    switch (target) {
 757    case GL_CLAMP_VERTEX_COLOR_ARB:
 758       FLUSH_VERTICES(ctx, _NEW_LIGHT);
 759       ctx->Light.ClampVertexColor = clamp;
 760       break;
 761    case GL_CLAMP_FRAGMENT_COLOR_ARB:
 762       FLUSH_VERTICES(ctx, _NEW_FRAG_CLAMP);
 763       ctx->Color.ClampFragmentColor = clamp;
 764       break;
 765    case GL_CLAMP_READ_COLOR_ARB:
 766       FLUSH_VERTICES(ctx, _NEW_COLOR);
 767       ctx->Color.ClampReadColor = clamp;
 768       break;
 769    default:
 770       _mesa_error(ctx, GL_INVALID_ENUM, "glClampColorARB(target)");
 771       return;
 772    }
 773 }
 774
 775
 776
 777
 778 /**********************************************************************/
 779 /** \name Initialization */
 780 /*@{*/
 781
 782 /**
 783  * Initialization of the context's Color attribute group.
 784  *
 785  * \param ctx GL context.
 786  *
 787  * Initializes the related fields in the context color attribute group,
 788  * __struct gl_contextRec::Color.
 789  */
 790 void _mesa_init_color( struct gl_context * ctx )
 791 {
 792    GLuint i;
 793
 794    /* Color buffer group */
 795    ctx->Color.IndexMask = ~0u;
 796    memset(ctx->Color.ColorMask, 0xff, sizeof(ctx->Color.ColorMask));
 797    ctx->Color.ClearIndex = 0;
 798    ASSIGN_4V( ctx->Color.ClearColor, 0, 0, 0, 0 );
 799    ASSIGN_4V( ctx->Color.ClearColorUnclamped, 0, 0, 0, 0 );
 800    ctx->Color.AlphaEnabled = GL_FALSE;
 801    ctx->Color.AlphaFunc = GL_ALWAYS;
 802    ctx->Color.AlphaRef = 0;
 803    ctx->Color.BlendEnabled = 0x0;
 804    for (i = 0; i < Elements(ctx->Color.Blend); i++) {
 805       ctx->Color.Blend[i].SrcRGB = GL_ONE;
 806       ctx->Color.Blend[i].DstRGB = GL_ZERO;
 807       ctx->Color.Blend[i].SrcA = GL_ONE;
 808       ctx->Color.Blend[i].DstA = GL_ZERO;
 809       ctx->Color.Blend[i].EquationRGB = GL_FUNC_ADD;
 810       ctx->Color.Blend[i].EquationA = GL_FUNC_ADD;
 811    }
 812    ASSIGN_4V( ctx->Color.BlendColor, 0.0, 0.0, 0.0, 0.0 );
 813    ASSIGN_4V( ctx->Color.BlendColorUnclamped, 0.0, 0.0, 0.0, 0.0 );
 814    ctx->Color.IndexLogicOpEnabled = GL_FALSE;
 815    ctx->Color.ColorLogicOpEnabled = GL_FALSE;
 816    ctx->Color._LogicOpEnabled = GL_FALSE;
 817    ctx->Color.LogicOp = GL_COPY;
 818    ctx->Color.DitherFlag = GL_TRUE;
 819
 820    if (ctx->Visual.doubleBufferMode) {
 821       ctx->Color.DrawBuffer[0] = GL_BACK;
 822    }
 823    else {
 824       ctx->Color.DrawBuffer[0] = GL_FRONT;
 825    }
 826
 827    ctx->Color.ClampFragmentColor = GL_FIXED_ONLY_ARB;
 828    ctx->Color._ClampFragmentColor = GL_TRUE;
 829    ctx->Color.ClampReadColor = GL_FIXED_ONLY_ARB;
 830    ctx->Color._ClampReadColor = GL_TRUE;
 831 }
 832
 833 /*@}*/