texenv.c revision 3464ebd5
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.5 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included 16 * in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26/** 27 * \file texenv.c 28 * 29 * glTexEnv-related functions 30 */ 31 32 33#include "main/glheader.h" 34#include "main/context.h" 35#include "main/enums.h" 36#include "main/macros.h" 37#include "main/mtypes.h" 38#include "main/state.h" 39#include "main/texenv.h" 40#include "main/texstate.h" 41 42 43#define TE_ERROR(errCode, msg, value) \ 44 _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value)); 45 46 47/** Set texture env mode */ 48static void 49set_env_mode(struct gl_context *ctx, 50 struct gl_texture_unit *texUnit, 51 GLenum mode) 52{ 53 GLboolean legal; 54 55 if (texUnit->EnvMode == mode) 56 return; 57 58 switch (mode) { 59 case GL_MODULATE: 60 case GL_BLEND: 61 case GL_DECAL: 62 case GL_REPLACE: 63 legal = GL_TRUE; 64 break; 65 case GL_REPLACE_EXT: 66 mode = GL_REPLACE; /* GL_REPLACE_EXT != GL_REPLACE */ 67 legal = GL_TRUE; 68 break; 69 case GL_ADD: 70 legal = ctx->Extensions.EXT_texture_env_add; 71 break; 72 case GL_COMBINE: 73 legal = (ctx->Extensions.EXT_texture_env_combine || 74 ctx->Extensions.ARB_texture_env_combine); 75 break; 76 case GL_COMBINE4_NV: 77 legal = ctx->Extensions.NV_texture_env_combine4; 78 break; 79 default: 80 legal = GL_FALSE; 81 } 82 83 if (legal) { 84 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 85 texUnit->EnvMode = mode; 86 } 87 else { 88 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); 89 } 90} 91 92 93static void 94set_env_color(struct gl_context *ctx, 95 struct gl_texture_unit *texUnit, 96 const GLfloat *color) 97{ 98 if (TEST_EQ_4V(color, texUnit->EnvColorUnclamped)) 99 return; 100 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 101 COPY_4FV(texUnit->EnvColorUnclamped, color); 102 texUnit->EnvColor[0] = CLAMP(color[0], 0.0F, 1.0F); 103 texUnit->EnvColor[1] = CLAMP(color[1], 0.0F, 1.0F); 104 texUnit->EnvColor[2] = CLAMP(color[2], 0.0F, 1.0F); 105 texUnit->EnvColor[3] = CLAMP(color[3], 0.0F, 1.0F); 106} 107 108 109/** Set an RGB or A combiner mode/function */ 110static void 111set_combiner_mode(struct gl_context *ctx, 112 struct gl_texture_unit *texUnit, 113 GLenum pname, GLenum mode) 114{ 115 GLboolean legal; 116 117 if (!ctx->Extensions.EXT_texture_env_combine && 118 !ctx->Extensions.ARB_texture_env_combine) { 119 _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); 120 return; 121 } 122 123 switch (mode) { 124 case GL_REPLACE: 125 case GL_MODULATE: 126 case GL_ADD: 127 case GL_ADD_SIGNED: 128 case GL_INTERPOLATE: 129 legal = GL_TRUE; 130 break; 131 case GL_SUBTRACT: 132 legal = ctx->Extensions.ARB_texture_env_combine; 133 break; 134 case GL_DOT3_RGB_EXT: 135 case GL_DOT3_RGBA_EXT: 136 legal = (ctx->Extensions.EXT_texture_env_dot3 && 137 pname == GL_COMBINE_RGB); 138 break; 139 case GL_DOT3_RGB: 140 case GL_DOT3_RGBA: 141 legal = (ctx->Extensions.ARB_texture_env_dot3 && 142 pname == GL_COMBINE_RGB); 143 break; 144 case GL_MODULATE_ADD_ATI: 145 case GL_MODULATE_SIGNED_ADD_ATI: 146 case GL_MODULATE_SUBTRACT_ATI: 147 legal = ctx->Extensions.ATI_texture_env_combine3; 148 break; 149 case GL_BUMP_ENVMAP_ATI: 150 legal = (ctx->Extensions.ATI_envmap_bumpmap && 151 pname == GL_COMBINE_RGB); 152 break; 153 default: 154 legal = GL_FALSE; 155 } 156 157 if (!legal) { 158 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode); 159 return; 160 } 161 162 switch (pname) { 163 case GL_COMBINE_RGB: 164 if (texUnit->Combine.ModeRGB == mode) 165 return; 166 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 167 texUnit->Combine.ModeRGB = mode; 168 break; 169 170 case GL_COMBINE_ALPHA: 171 if (texUnit->Combine.ModeA == mode) 172 return; 173 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 174 texUnit->Combine.ModeA = mode; 175 break; 176 default: 177 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 178 } 179} 180 181 182 183/** Set an RGB or A combiner source term */ 184static void 185set_combiner_source(struct gl_context *ctx, 186 struct gl_texture_unit *texUnit, 187 GLenum pname, GLenum param) 188{ 189 GLuint term; 190 GLboolean alpha, legal; 191 192 if (!ctx->Extensions.EXT_texture_env_combine && 193 !ctx->Extensions.ARB_texture_env_combine) { 194 _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); 195 return; 196 } 197 198 /* 199 * Translate pname to (term, alpha). 200 * 201 * The enums were given sequential values for a reason. 202 */ 203 switch (pname) { 204 case GL_SOURCE0_RGB: 205 case GL_SOURCE1_RGB: 206 case GL_SOURCE2_RGB: 207 case GL_SOURCE3_RGB_NV: 208 term = pname - GL_SOURCE0_RGB; 209 alpha = GL_FALSE; 210 break; 211 case GL_SOURCE0_ALPHA: 212 case GL_SOURCE1_ALPHA: 213 case GL_SOURCE2_ALPHA: 214 case GL_SOURCE3_ALPHA_NV: 215 term = pname - GL_SOURCE0_ALPHA; 216 alpha = GL_TRUE; 217 break; 218 default: 219 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 220 return; 221 } 222 223 if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) { 224 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 225 return; 226 } 227 228 assert(term < MAX_COMBINER_TERMS); 229 230 /* 231 * Error-check param (the source term) 232 */ 233 switch (param) { 234 case GL_TEXTURE: 235 case GL_CONSTANT: 236 case GL_PRIMARY_COLOR: 237 case GL_PREVIOUS: 238 legal = GL_TRUE; 239 break; 240 case GL_TEXTURE0: 241 case GL_TEXTURE1: 242 case GL_TEXTURE2: 243 case GL_TEXTURE3: 244 case GL_TEXTURE4: 245 case GL_TEXTURE5: 246 case GL_TEXTURE6: 247 case GL_TEXTURE7: 248 legal = (ctx->Extensions.ARB_texture_env_crossbar && 249 param - GL_TEXTURE0 < ctx->Const.MaxTextureUnits); 250 break; 251 case GL_ZERO: 252 legal = (ctx->Extensions.ATI_texture_env_combine3 || 253 ctx->Extensions.NV_texture_env_combine4); 254 break; 255 case GL_ONE: 256 legal = ctx->Extensions.ATI_texture_env_combine3; 257 break; 258 default: 259 legal = GL_FALSE; 260 } 261 262 if (!legal) { 263 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param); 264 return; 265 } 266 267 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 268 269 if (alpha) 270 texUnit->Combine.SourceA[term] = param; 271 else 272 texUnit->Combine.SourceRGB[term] = param; 273} 274 275 276/** Set an RGB or A combiner operand term */ 277static void 278set_combiner_operand(struct gl_context *ctx, 279 struct gl_texture_unit *texUnit, 280 GLenum pname, GLenum param) 281{ 282 GLuint term; 283 GLboolean alpha, legal; 284 285 if (!ctx->Extensions.EXT_texture_env_combine && 286 !ctx->Extensions.ARB_texture_env_combine) { 287 _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); 288 return; 289 } 290 291 /* The enums were given sequential values for a reason. 292 */ 293 switch (pname) { 294 case GL_OPERAND0_RGB: 295 case GL_OPERAND1_RGB: 296 case GL_OPERAND2_RGB: 297 case GL_OPERAND3_RGB_NV: 298 term = pname - GL_OPERAND0_RGB; 299 alpha = GL_FALSE; 300 break; 301 case GL_OPERAND0_ALPHA: 302 case GL_OPERAND1_ALPHA: 303 case GL_OPERAND2_ALPHA: 304 case GL_OPERAND3_ALPHA_NV: 305 term = pname - GL_OPERAND0_ALPHA; 306 alpha = GL_TRUE; 307 break; 308 default: 309 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 310 return; 311 } 312 313 if ((term == 3) && !ctx->Extensions.NV_texture_env_combine4) { 314 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 315 return; 316 } 317 318 assert(term < MAX_COMBINER_TERMS); 319 320 /* 321 * Error-check param (the source operand) 322 */ 323 switch (param) { 324 case GL_SRC_COLOR: 325 case GL_ONE_MINUS_SRC_COLOR: 326 /* The color input can only be used with GL_OPERAND[01]_RGB in the EXT 327 * version. In the ARB and NV versions they can be used for any RGB 328 * operand. 329 */ 330 legal = !alpha 331 && ((term < 2) || ctx->Extensions.ARB_texture_env_combine 332 || ctx->Extensions.NV_texture_env_combine4); 333 break; 334 case GL_ONE_MINUS_SRC_ALPHA: 335 /* GL_ONE_MINUS_SRC_ALPHA can only be used with 336 * GL_OPERAND[01]_(RGB|ALPHA) in the EXT version. In the ARB and NV 337 * versions it can be used for any operand. 338 */ 339 legal = (term < 2) || ctx->Extensions.ARB_texture_env_combine 340 || ctx->Extensions.NV_texture_env_combine4; 341 break; 342 case GL_SRC_ALPHA: 343 legal = GL_TRUE; 344 break; 345 default: 346 legal = GL_FALSE; 347 } 348 349 if (!legal) { 350 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", param); 351 return; 352 } 353 354 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 355 356 if (alpha) 357 texUnit->Combine.OperandA[term] = param; 358 else 359 texUnit->Combine.OperandRGB[term] = param; 360} 361 362 363static void 364set_combiner_scale(struct gl_context *ctx, 365 struct gl_texture_unit *texUnit, 366 GLenum pname, GLfloat scale) 367{ 368 GLuint shift; 369 370 if (!ctx->Extensions.EXT_texture_env_combine && 371 !ctx->Extensions.ARB_texture_env_combine) { 372 _mesa_error(ctx, GL_INVALID_ENUM, "glTexEnv(pname)"); 373 return; 374 } 375 376 if (scale == 1.0F) { 377 shift = 0; 378 } 379 else if (scale == 2.0F) { 380 shift = 1; 381 } 382 else if (scale == 4.0F) { 383 shift = 2; 384 } 385 else { 386 _mesa_error( ctx, GL_INVALID_VALUE, 387 "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" ); 388 return; 389 } 390 391 switch (pname) { 392 case GL_RGB_SCALE: 393 if (texUnit->Combine.ScaleShiftRGB == shift) 394 return; 395 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 396 texUnit->Combine.ScaleShiftRGB = shift; 397 break; 398 case GL_ALPHA_SCALE: 399 if (texUnit->Combine.ScaleShiftA == shift) 400 return; 401 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 402 texUnit->Combine.ScaleShiftA = shift; 403 break; 404 default: 405 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 406 } 407} 408 409 410 411void GLAPIENTRY 412_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param ) 413{ 414 const GLint iparam0 = (GLint) param[0]; 415 struct gl_texture_unit *texUnit; 416 GLuint maxUnit; 417 418 GET_CURRENT_CONTEXT(ctx); 419 ASSERT_OUTSIDE_BEGIN_END(ctx); 420 421 maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV) 422 ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits; 423 if (ctx->Texture.CurrentUnit >= maxUnit) { 424 _mesa_error(ctx, GL_INVALID_OPERATION, "glTexEnvfv(current unit)"); 425 return; 426 } 427 428 texUnit = _mesa_get_current_tex_unit(ctx); 429 430 if (target == GL_TEXTURE_ENV) { 431 switch (pname) { 432 case GL_TEXTURE_ENV_MODE: 433 set_env_mode(ctx, texUnit, (GLenum) iparam0); 434 break; 435 case GL_TEXTURE_ENV_COLOR: 436 set_env_color(ctx, texUnit, param); 437 break; 438 case GL_COMBINE_RGB: 439 case GL_COMBINE_ALPHA: 440 set_combiner_mode(ctx, texUnit, pname, (GLenum) iparam0); 441 break; 442 case GL_SOURCE0_RGB: 443 case GL_SOURCE1_RGB: 444 case GL_SOURCE2_RGB: 445 case GL_SOURCE3_RGB_NV: 446 case GL_SOURCE0_ALPHA: 447 case GL_SOURCE1_ALPHA: 448 case GL_SOURCE2_ALPHA: 449 case GL_SOURCE3_ALPHA_NV: 450 set_combiner_source(ctx, texUnit, pname, (GLenum) iparam0); 451 break; 452 case GL_OPERAND0_RGB: 453 case GL_OPERAND1_RGB: 454 case GL_OPERAND2_RGB: 455 case GL_OPERAND3_RGB_NV: 456 case GL_OPERAND0_ALPHA: 457 case GL_OPERAND1_ALPHA: 458 case GL_OPERAND2_ALPHA: 459 case GL_OPERAND3_ALPHA_NV: 460 set_combiner_operand(ctx, texUnit, pname, (GLenum) iparam0); 461 break; 462 case GL_RGB_SCALE: 463 case GL_ALPHA_SCALE: 464 set_combiner_scale(ctx, texUnit, pname, param[0]); 465 break; 466 case GL_BUMP_TARGET_ATI: 467 if (!ctx->Extensions.ATI_envmap_bumpmap) { 468 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname ); 469 return; 470 } 471 if ((iparam0 < GL_TEXTURE0) || 472 (iparam0 > GL_TEXTURE31)) { 473 /* spec doesn't say this but it seems logical */ 474 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param=0x%x)", iparam0); 475 return; 476 } 477 if (!((1 << (iparam0 - GL_TEXTURE0)) & ctx->Const.SupportedBumpUnits)) { 478 _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0); 479 return; 480 } 481 else { 482 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 483 texUnit->BumpTarget = iparam0; 484 } 485 break; 486 default: 487 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" ); 488 return; 489 } 490 } 491 else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) { 492 /* GL_EXT_texture_lod_bias */ 493 if (!ctx->Extensions.EXT_texture_lod_bias) { 494 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target ); 495 return; 496 } 497 if (pname == GL_TEXTURE_LOD_BIAS_EXT) { 498 if (texUnit->LodBias == param[0]) 499 return; 500 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 501 texUnit->LodBias = param[0]; 502 } 503 else { 504 TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname); 505 return; 506 } 507 } 508 else if (target == GL_POINT_SPRITE_NV) { 509 /* GL_ARB_point_sprite / GL_NV_point_sprite */ 510 if (!ctx->Extensions.NV_point_sprite 511 && !ctx->Extensions.ARB_point_sprite) { 512 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target ); 513 return; 514 } 515 if (pname == GL_COORD_REPLACE_NV) { 516 if (iparam0 == GL_TRUE || iparam0 == GL_FALSE) { 517 /* It's kind of weird to set point state via glTexEnv, 518 * but that's what the spec calls for. 519 */ 520 const GLboolean state = (GLboolean) iparam0; 521 if (ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] == state) 522 return; 523 FLUSH_VERTICES(ctx, _NEW_POINT); 524 ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] = state; 525 } 526 else { 527 _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", iparam0); 528 return; 529 } 530 } 531 else { 532 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname ); 533 return; 534 } 535 } 536 else { 537 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)",target ); 538 return; 539 } 540 541 if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE)) 542 _mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n", 543 _mesa_lookup_enum_by_nr(target), 544 _mesa_lookup_enum_by_nr(pname), 545 *param, 546 _mesa_lookup_enum_by_nr((GLenum) iparam0)); 547 548 /* Tell device driver about the new texture environment */ 549 if (ctx->Driver.TexEnv) { 550 (*ctx->Driver.TexEnv)( ctx, target, pname, param ); 551 } 552} 553 554 555void GLAPIENTRY 556_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param ) 557{ 558 GLfloat p[4]; 559 p[0] = param; 560 p[1] = p[2] = p[3] = 0.0; 561 _mesa_TexEnvfv( target, pname, p ); 562} 563 564 565 566void GLAPIENTRY 567_mesa_TexEnvi( GLenum target, GLenum pname, GLint param ) 568{ 569 GLfloat p[4]; 570 p[0] = (GLfloat) param; 571 p[1] = p[2] = p[3] = 0.0; 572 _mesa_TexEnvfv( target, pname, p ); 573} 574 575 576void GLAPIENTRY 577_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param ) 578{ 579 GLfloat p[4]; 580 if (pname == GL_TEXTURE_ENV_COLOR) { 581 p[0] = INT_TO_FLOAT( param[0] ); 582 p[1] = INT_TO_FLOAT( param[1] ); 583 p[2] = INT_TO_FLOAT( param[2] ); 584 p[3] = INT_TO_FLOAT( param[3] ); 585 } 586 else { 587 p[0] = (GLfloat) param[0]; 588 p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */ 589 } 590 _mesa_TexEnvfv( target, pname, p ); 591} 592 593 594 595/** 596 * Helper for glGetTexEnvi/f() 597 * \return value of queried pname or -1 if error. 598 */ 599static GLint 600get_texenvi(struct gl_context *ctx, const struct gl_texture_unit *texUnit, 601 GLenum pname) 602{ 603 switch (pname) { 604 case GL_TEXTURE_ENV_MODE: 605 return texUnit->EnvMode; 606 break; 607 case GL_COMBINE_RGB: 608 if (ctx->Extensions.EXT_texture_env_combine || 609 ctx->Extensions.ARB_texture_env_combine) { 610 return texUnit->Combine.ModeRGB; 611 } 612 else { 613 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 614 } 615 break; 616 case GL_COMBINE_ALPHA: 617 if (ctx->Extensions.EXT_texture_env_combine || 618 ctx->Extensions.ARB_texture_env_combine) { 619 return texUnit->Combine.ModeA; 620 } 621 else { 622 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 623 } 624 break; 625 case GL_SOURCE0_RGB: 626 case GL_SOURCE1_RGB: 627 case GL_SOURCE2_RGB: 628 if (ctx->Extensions.EXT_texture_env_combine || 629 ctx->Extensions.ARB_texture_env_combine) { 630 const unsigned rgb_idx = pname - GL_SOURCE0_RGB; 631 return texUnit->Combine.SourceRGB[rgb_idx]; 632 } 633 else { 634 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 635 } 636 break; 637 case GL_SOURCE3_RGB_NV: 638 if (ctx->Extensions.NV_texture_env_combine4) { 639 return texUnit->Combine.SourceRGB[3]; 640 } 641 else { 642 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 643 } 644 break; 645 case GL_SOURCE0_ALPHA: 646 case GL_SOURCE1_ALPHA: 647 case GL_SOURCE2_ALPHA: 648 if (ctx->Extensions.EXT_texture_env_combine || 649 ctx->Extensions.ARB_texture_env_combine) { 650 const unsigned alpha_idx = pname - GL_SOURCE0_ALPHA; 651 return texUnit->Combine.SourceA[alpha_idx]; 652 } 653 else { 654 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 655 } 656 break; 657 case GL_SOURCE3_ALPHA_NV: 658 if (ctx->Extensions.NV_texture_env_combine4) { 659 return texUnit->Combine.SourceA[3]; 660 } 661 else { 662 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 663 } 664 break; 665 case GL_OPERAND0_RGB: 666 case GL_OPERAND1_RGB: 667 case GL_OPERAND2_RGB: 668 if (ctx->Extensions.EXT_texture_env_combine || 669 ctx->Extensions.ARB_texture_env_combine) { 670 const unsigned op_rgb = pname - GL_OPERAND0_RGB; 671 return texUnit->Combine.OperandRGB[op_rgb]; 672 } 673 else { 674 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 675 } 676 break; 677 case GL_OPERAND3_RGB_NV: 678 if (ctx->Extensions.NV_texture_env_combine4) { 679 return texUnit->Combine.OperandRGB[3]; 680 } 681 else { 682 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 683 } 684 break; 685 case GL_OPERAND0_ALPHA: 686 case GL_OPERAND1_ALPHA: 687 case GL_OPERAND2_ALPHA: 688 if (ctx->Extensions.EXT_texture_env_combine || 689 ctx->Extensions.ARB_texture_env_combine) { 690 const unsigned op_alpha = pname - GL_OPERAND0_ALPHA; 691 return texUnit->Combine.OperandA[op_alpha]; 692 } 693 else { 694 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 695 } 696 break; 697 case GL_OPERAND3_ALPHA_NV: 698 if (ctx->Extensions.NV_texture_env_combine4) { 699 return texUnit->Combine.OperandA[3]; 700 } 701 else { 702 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 703 } 704 break; 705 case GL_RGB_SCALE: 706 if (ctx->Extensions.EXT_texture_env_combine || 707 ctx->Extensions.ARB_texture_env_combine) { 708 return 1 << texUnit->Combine.ScaleShiftRGB; 709 } 710 else { 711 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 712 } 713 break; 714 case GL_ALPHA_SCALE: 715 if (ctx->Extensions.EXT_texture_env_combine || 716 ctx->Extensions.ARB_texture_env_combine) { 717 return 1 << texUnit->Combine.ScaleShiftA; 718 } 719 else { 720 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 721 } 722 break; 723 case GL_BUMP_TARGET_ATI: 724 /* spec doesn't say so, but I think this should be queryable */ 725 if (ctx->Extensions.ATI_envmap_bumpmap) { 726 return texUnit->BumpTarget; 727 } 728 else { 729 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 730 } 731 break; 732 733 default: 734 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)"); 735 break; 736 } 737 738 return -1; /* error */ 739} 740 741 742 743void GLAPIENTRY 744_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) 745{ 746 GLuint maxUnit; 747 const struct gl_texture_unit *texUnit; 748 GET_CURRENT_CONTEXT(ctx); 749 ASSERT_OUTSIDE_BEGIN_END(ctx); 750 751 maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV) 752 ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits; 753 if (ctx->Texture.CurrentUnit >= maxUnit) { 754 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnvfv(current unit)"); 755 return; 756 } 757 758 texUnit = _mesa_get_current_tex_unit(ctx); 759 760 if (target == GL_TEXTURE_ENV) { 761 if (pname == GL_TEXTURE_ENV_COLOR) { 762 if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP)) 763 _mesa_update_state(ctx); 764 if(ctx->Color._ClampFragmentColor) 765 COPY_4FV( params, texUnit->EnvColor ); 766 else 767 COPY_4FV( params, texUnit->EnvColorUnclamped ); 768 } 769 else { 770 GLint val = get_texenvi(ctx, texUnit, pname); 771 if (val >= 0) { 772 *params = (GLfloat) val; 773 } 774 } 775 } 776 else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) { 777 /* GL_EXT_texture_lod_bias */ 778 if (!ctx->Extensions.EXT_texture_lod_bias) { 779 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" ); 780 return; 781 } 782 if (pname == GL_TEXTURE_LOD_BIAS_EXT) { 783 *params = texUnit->LodBias; 784 } 785 else { 786 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" ); 787 return; 788 } 789 } 790 else if (target == GL_POINT_SPRITE_NV) { 791 /* GL_ARB_point_sprite / GL_NV_point_sprite */ 792 if (!ctx->Extensions.NV_point_sprite 793 && !ctx->Extensions.ARB_point_sprite) { 794 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" ); 795 return; 796 } 797 if (pname == GL_COORD_REPLACE_NV) { 798 *params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit]; 799 } 800 else { 801 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" ); 802 return; 803 } 804 } 805 else { 806 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" ); 807 return; 808 } 809} 810 811 812void GLAPIENTRY 813_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params ) 814{ 815 GLuint maxUnit; 816 const struct gl_texture_unit *texUnit; 817 GET_CURRENT_CONTEXT(ctx); 818 ASSERT_OUTSIDE_BEGIN_END(ctx); 819 820 maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV) 821 ? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits; 822 if (ctx->Texture.CurrentUnit >= maxUnit) { 823 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnviv(current unit)"); 824 return; 825 } 826 827 texUnit = _mesa_get_current_tex_unit(ctx); 828 829 if (target == GL_TEXTURE_ENV) { 830 if (pname == GL_TEXTURE_ENV_COLOR) { 831 params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] ); 832 params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] ); 833 params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] ); 834 params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] ); 835 } 836 else { 837 GLint val = get_texenvi(ctx, texUnit, pname); 838 if (val >= 0) { 839 *params = val; 840 } 841 } 842 } 843 else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) { 844 /* GL_EXT_texture_lod_bias */ 845 if (!ctx->Extensions.EXT_texture_lod_bias) { 846 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" ); 847 return; 848 } 849 if (pname == GL_TEXTURE_LOD_BIAS_EXT) { 850 *params = (GLint) texUnit->LodBias; 851 } 852 else { 853 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" ); 854 return; 855 } 856 } 857 else if (target == GL_POINT_SPRITE_NV) { 858 /* GL_ARB_point_sprite / GL_NV_point_sprite */ 859 if (!ctx->Extensions.NV_point_sprite 860 && !ctx->Extensions.ARB_point_sprite) { 861 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" ); 862 return; 863 } 864 if (pname == GL_COORD_REPLACE_NV) { 865 *params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit]; 866 } 867 else { 868 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" ); 869 return; 870 } 871 } 872 else { 873 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" ); 874 return; 875 } 876} 877 878 879/** 880 * Why does ATI_envmap_bumpmap require new entrypoints? Should just 881 * reuse TexEnv ones... 882 */ 883void GLAPIENTRY 884_mesa_TexBumpParameterivATI( GLenum pname, const GLint *param ) 885{ 886 GLfloat p[4]; 887 GET_CURRENT_CONTEXT(ctx); 888 ASSERT_OUTSIDE_BEGIN_END(ctx); 889 890 if (!ctx->Extensions.ATI_envmap_bumpmap) { 891 /* This isn't an "official" error case, but let's tell the user 892 * that something's wrong. 893 */ 894 _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterivATI"); 895 return; 896 } 897 898 if (pname == GL_BUMP_ROT_MATRIX_ATI) { 899 /* hope that conversion is correct here */ 900 p[0] = INT_TO_FLOAT( param[0] ); 901 p[1] = INT_TO_FLOAT( param[1] ); 902 p[2] = INT_TO_FLOAT( param[2] ); 903 p[3] = INT_TO_FLOAT( param[3] ); 904 } 905 else { 906 p[0] = (GLfloat) param[0]; 907 p[1] = p[2] = p[3] = 0.0F; /* init to zero, just to be safe */ 908 } 909 _mesa_TexBumpParameterfvATI( pname, p ); 910} 911 912 913void GLAPIENTRY 914_mesa_TexBumpParameterfvATI( GLenum pname, const GLfloat *param ) 915{ 916 struct gl_texture_unit *texUnit; 917 GET_CURRENT_CONTEXT(ctx); 918 ASSERT_OUTSIDE_BEGIN_END(ctx); 919 920 if (!ctx->Extensions.ATI_envmap_bumpmap) { 921 _mesa_error(ctx, GL_INVALID_OPERATION, "glTexBumpParameterfvATI"); 922 return; 923 } 924 925 texUnit = _mesa_get_current_tex_unit(ctx); 926 927 if (pname == GL_BUMP_ROT_MATRIX_ATI) { 928 if (TEST_EQ_4V(param, texUnit->RotMatrix)) 929 return; 930 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 931 COPY_4FV(texUnit->RotMatrix, param); 932 } 933 else { 934 _mesa_error( ctx, GL_INVALID_ENUM, "glTexBumpParameter(pname)" ); 935 return; 936 } 937 /* Drivers might want to know about this, instead of dedicated function 938 just shove it into TexEnv where it really belongs anyway */ 939 if (ctx->Driver.TexEnv) { 940 (*ctx->Driver.TexEnv)( ctx, 0, pname, param ); 941 } 942} 943 944 945void GLAPIENTRY 946_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param ) 947{ 948 const struct gl_texture_unit *texUnit; 949 GLuint i; 950 GET_CURRENT_CONTEXT(ctx); 951 ASSERT_OUTSIDE_BEGIN_END(ctx); 952 953 if (!ctx->Extensions.ATI_envmap_bumpmap) { 954 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI"); 955 return; 956 } 957 958 texUnit = _mesa_get_current_tex_unit(ctx); 959 960 if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { 961 /* spec leaves open to support larger matrices. 962 Don't think anyone would ever want to use it 963 (and apps almost certainly would not understand it and 964 thus fail to submit matrices correctly) so hardcode this. */ 965 *param = 4; 966 } 967 else if (pname == GL_BUMP_ROT_MATRIX_ATI) { 968 /* hope that conversion is correct here */ 969 param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]); 970 param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]); 971 param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]); 972 param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]); 973 } 974 else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { 975 GLint count = 0; 976 for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { 977 if (ctx->Const.SupportedBumpUnits & (1 << i)) { 978 count++; 979 } 980 } 981 *param = count; 982 } 983 else if (pname == GL_BUMP_TEX_UNITS_ATI) { 984 for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { 985 if (ctx->Const.SupportedBumpUnits & (1 << i)) { 986 *param++ = i + GL_TEXTURE0; 987 } 988 } 989 } 990 else { 991 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); 992 return; 993 } 994} 995 996 997void GLAPIENTRY 998_mesa_GetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) 999{ 1000 const struct gl_texture_unit *texUnit; 1001 GLuint i; 1002 GET_CURRENT_CONTEXT(ctx); 1003 ASSERT_OUTSIDE_BEGIN_END(ctx); 1004 1005 if (!ctx->Extensions.ATI_envmap_bumpmap) { 1006 _mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterfvATI"); 1007 return; 1008 } 1009 1010 texUnit = _mesa_get_current_tex_unit(ctx); 1011 1012 if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) { 1013 /* spec leaves open to support larger matrices. 1014 Don't think anyone would ever want to use it 1015 (and apps might not understand it) so hardcode this. */ 1016 *param = 4.0F; 1017 } 1018 else if (pname == GL_BUMP_ROT_MATRIX_ATI) { 1019 param[0] = texUnit->RotMatrix[0]; 1020 param[1] = texUnit->RotMatrix[1]; 1021 param[2] = texUnit->RotMatrix[2]; 1022 param[3] = texUnit->RotMatrix[3]; 1023 } 1024 else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) { 1025 GLint count = 0; 1026 for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { 1027 if (ctx->Const.SupportedBumpUnits & (1 << i)) { 1028 count++; 1029 } 1030 } 1031 *param = (GLfloat) count; 1032 } 1033 else if (pname == GL_BUMP_TEX_UNITS_ATI) { 1034 for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) { 1035 if (ctx->Const.SupportedBumpUnits & (1 << i)) { 1036 *param++ = (GLfloat) (i + GL_TEXTURE0); 1037 } 1038 } 1039 } 1040 else { 1041 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" ); 1042 return; 1043 } 1044} 1045