1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 2011 VMware, Inc. 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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 20 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 22 */ 23 24 25 /** 26 * \file samplerobj.c 27 * \brief Functions for the GL_ARB_sampler_objects extension. 28 * \author Brian Paul 29 */ 30 31 32 #include "main/glheader.h" 33 #include "main/context.h" 34 #include "main/dispatch.h" 35 #include "main/enums.h" 36 #include "main/hash.h" 37 #include "main/macros.h" 38 #include "main/mfeatures.h" 39 #include "main/mtypes.h" 40 #include "main/samplerobj.h" 41 42 43 static struct gl_sampler_object * 44 _mesa_lookup_samplerobj(struct gl_context *ctx, GLuint name) 45 { 46 if (name == 0) 47 return NULL; 48 else 49 return (struct gl_sampler_object *) 50 _mesa_HashLookup(ctx->Shared->SamplerObjects, name); 51 } 52 53 54 /** 55 * Handle reference counting. 56 */ 57 void 58 _mesa_reference_sampler_object_(struct gl_context *ctx, 59 struct gl_sampler_object **ptr, 60 struct gl_sampler_object *samp) 61 { 62 assert(*ptr != samp); /* The inline wrapper should prevent no-op calls */ 63 64 if (*ptr) { 65 /* Unreference the old sampler */ 66 GLboolean deleteFlag = GL_FALSE; 67 struct gl_sampler_object *oldSamp = *ptr; 68 69 /*_glthread_LOCK_MUTEX(oldSamp->Mutex);*/ 70 ASSERT(oldSamp->RefCount > 0); 71 oldSamp->RefCount--; 72 #if 0 73 printf("SamplerObj %p %d DECR to %d\n", 74 (void *) oldSamp, oldSamp->Name, oldSamp->RefCount); 75 #endif 76 deleteFlag = (oldSamp->RefCount == 0); 77 /*_glthread_UNLOCK_MUTEX(oldSamp->Mutex);*/ 78 79 if (deleteFlag) { 80 ASSERT(ctx->Driver.DeleteSamplerObject); 81 ctx->Driver.DeleteSamplerObject(ctx, oldSamp); 82 } 83 84 *ptr = NULL; 85 } 86 ASSERT(!*ptr); 87 88 if (samp) { 89 /* reference new sampler */ 90 /*_glthread_LOCK_MUTEX(samp->Mutex);*/ 91 if (samp->RefCount == 0) { 92 /* this sampler's being deleted (look just above) */ 93 /* Not sure this can every really happen. Warn if it does. */ 94 _mesa_problem(NULL, "referencing deleted sampler object"); 95 *ptr = NULL; 96 } 97 else { 98 samp->RefCount++; 99 #if 0 100 printf("SamplerObj %p %d INCR to %d\n", 101 (void *) samp, samp->Name, samp->RefCount); 102 #endif 103 *ptr = samp; 104 } 105 /*_glthread_UNLOCK_MUTEX(samp->Mutex);*/ 106 } 107 } 108 109 110 /** 111 * Initialize the fields of the given sampler object. 112 */ 113 void 114 _mesa_init_sampler_object(struct gl_sampler_object *sampObj, GLuint name) 115 { 116 sampObj->Name = name; 117 sampObj->RefCount = 1; 118 sampObj->WrapS = GL_REPEAT; 119 sampObj->WrapT = GL_REPEAT; 120 sampObj->WrapR = GL_REPEAT; 121 sampObj->MinFilter = GL_NEAREST_MIPMAP_LINEAR; 122 sampObj->MagFilter = GL_LINEAR; 123 sampObj->BorderColor.f[0] = 0.0; 124 sampObj->BorderColor.f[1] = 0.0; 125 sampObj->BorderColor.f[2] = 0.0; 126 sampObj->BorderColor.f[3] = 0.0; 127 sampObj->MinLod = -1000.0F; 128 sampObj->MaxLod = 1000.0F; 129 sampObj->LodBias = 0.0F; 130 sampObj->MaxAnisotropy = 1.0F; 131 sampObj->CompareMode = GL_NONE; 132 sampObj->CompareFunc = GL_LEQUAL; 133 sampObj->sRGBDecode = GL_DECODE_EXT; 134 sampObj->CubeMapSeamless = GL_FALSE; 135 } 136 137 /** 138 * Fallback for ctx->Driver.NewSamplerObject(); 139 */ 140 struct gl_sampler_object * 141 _mesa_new_sampler_object(struct gl_context *ctx, GLuint name) 142 { 143 struct gl_sampler_object *sampObj = CALLOC_STRUCT(gl_sampler_object); 144 if (sampObj) { 145 _mesa_init_sampler_object(sampObj, name); 146 } 147 return sampObj; 148 } 149 150 151 /** 152 * Fallback for ctx->Driver.DeleteSamplerObject(); 153 */ 154 void 155 _mesa_delete_sampler_object(struct gl_context *ctx, 156 struct gl_sampler_object *sampObj) 157 { 158 FREE(sampObj); 159 } 160 161 162 void GLAPIENTRY 163 _mesa_GenSamplers(GLsizei count, GLuint *samplers) 164 { 165 GET_CURRENT_CONTEXT(ctx); 166 GLuint first; 167 GLint i; 168 169 ASSERT_OUTSIDE_BEGIN_END(ctx); 170 171 if (MESA_VERBOSE & VERBOSE_API) 172 _mesa_debug(ctx, "glGenSamplers(%d)\n", count); 173 174 if (count < 0) { 175 _mesa_error(ctx, GL_INVALID_VALUE, "glGenSamplers"); 176 return; 177 } 178 179 if (!samplers) 180 return; 181 182 first = _mesa_HashFindFreeKeyBlock(ctx->Shared->SamplerObjects, count); 183 184 /* Insert the ID and pointer to new sampler object into hash table */ 185 for (i = 0; i < count; i++) { 186 struct gl_sampler_object *sampObj = 187 ctx->Driver.NewSamplerObject(ctx, first + i); 188 _mesa_HashInsert(ctx->Shared->SamplerObjects, first + i, sampObj); 189 samplers[i] = first + i; 190 } 191 } 192 193 194 void GLAPIENTRY 195 _mesa_DeleteSamplers(GLsizei count, const GLuint *samplers) 196 { 197 GET_CURRENT_CONTEXT(ctx); 198 GLsizei i; 199 200 ASSERT_OUTSIDE_BEGIN_END(ctx); 201 FLUSH_VERTICES(ctx, 0); 202 203 if (count < 0) { 204 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteSamplers(count)"); 205 return; 206 } 207 208 _glthread_LOCK_MUTEX(ctx->Shared->Mutex); 209 210 for (i = 0; i < count; i++) { 211 if (samplers[i]) { 212 struct gl_sampler_object *sampObj = 213 _mesa_lookup_samplerobj(ctx, samplers[i]); 214 if (sampObj) { 215 /* The ID is immediately freed for re-use */ 216 _mesa_HashRemove(ctx->Shared->SamplerObjects, samplers[i]); 217 /* But the object exists until its reference count goes to zero */ 218 _mesa_reference_sampler_object(ctx, &sampObj, NULL); 219 } 220 } 221 } 222 223 _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex); 224 } 225 226 227 static GLboolean GLAPIENTRY 228 _mesa_IsSampler(GLuint sampler) 229 { 230 struct gl_sampler_object *sampObj; 231 GET_CURRENT_CONTEXT(ctx); 232 233 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); 234 235 if (sampler == 0) 236 return GL_FALSE; 237 238 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 239 240 return sampObj != NULL; 241 } 242 243 244 void GLAPIENTRY 245 _mesa_BindSampler(GLuint unit, GLuint sampler) 246 { 247 struct gl_sampler_object *sampObj; 248 GET_CURRENT_CONTEXT(ctx); 249 250 if (unit >= ctx->Const.MaxCombinedTextureImageUnits) { 251 _mesa_error(ctx, GL_INVALID_VALUE, "glBindSampler(unit %u)", unit); 252 return; 253 } 254 255 if (sampler == 0) { 256 /* Use the default sampler object, the one contained in the texture 257 * object. 258 */ 259 sampObj = NULL; 260 } 261 else { 262 /* user-defined sampler object */ 263 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 264 if (!sampObj) { 265 _mesa_error(ctx, GL_INVALID_OPERATION, "glBindSampler(sampler)"); 266 return; 267 } 268 } 269 270 if (ctx->Texture.Unit[unit].Sampler != sampObj) { 271 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 272 } 273 274 /* bind new sampler */ 275 _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[unit].Sampler, 276 sampObj); 277 } 278 279 280 /** 281 * Check if a coordinate wrap mode is legal. 282 * \return GL_TRUE if legal, GL_FALSE otherwise 283 */ 284 static GLboolean 285 validate_texture_wrap_mode(struct gl_context *ctx, GLenum wrap) 286 { 287 const struct gl_extensions * const e = &ctx->Extensions; 288 289 switch (wrap) { 290 case GL_CLAMP: 291 case GL_CLAMP_TO_EDGE: 292 case GL_REPEAT: 293 case GL_MIRRORED_REPEAT: 294 return GL_TRUE; 295 case GL_CLAMP_TO_BORDER: 296 return e->ARB_texture_border_clamp; 297 case GL_MIRROR_CLAMP_EXT: 298 return e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp; 299 case GL_MIRROR_CLAMP_TO_EDGE_EXT: 300 return e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp; 301 case GL_MIRROR_CLAMP_TO_BORDER_EXT: 302 return e->EXT_texture_mirror_clamp; 303 default: 304 return GL_FALSE; 305 } 306 } 307 308 309 /** 310 * This is called just prior to changing any sampler object state. 311 */ 312 static inline void 313 flush(struct gl_context *ctx) 314 { 315 FLUSH_VERTICES(ctx, _NEW_TEXTURE); 316 } 317 318 319 #define INVALID_PARAM 0x100 320 #define INVALID_PNAME 0x101 321 #define INVALID_VALUE 0x102 322 323 static GLuint 324 set_sampler_wrap_s(struct gl_context *ctx, struct gl_sampler_object *samp, 325 GLint param) 326 { 327 if (samp->WrapS == param) 328 return GL_FALSE; 329 if (validate_texture_wrap_mode(ctx, param)) { 330 flush(ctx); 331 samp->WrapS = param; 332 return GL_TRUE; 333 } 334 return INVALID_PARAM; 335 } 336 337 338 static GLuint 339 set_sampler_wrap_t(struct gl_context *ctx, struct gl_sampler_object *samp, 340 GLint param) 341 { 342 if (samp->WrapT == param) 343 return GL_FALSE; 344 if (validate_texture_wrap_mode(ctx, param)) { 345 flush(ctx); 346 samp->WrapT = param; 347 return GL_TRUE; 348 } 349 return INVALID_PARAM; 350 } 351 352 353 static GLuint 354 set_sampler_wrap_r(struct gl_context *ctx, struct gl_sampler_object *samp, 355 GLint param) 356 { 357 if (samp->WrapR == param) 358 return GL_FALSE; 359 if (validate_texture_wrap_mode(ctx, param)) { 360 flush(ctx); 361 samp->WrapR = param; 362 return GL_TRUE; 363 } 364 return INVALID_PARAM; 365 } 366 367 368 static GLuint 369 set_sampler_min_filter(struct gl_context *ctx, struct gl_sampler_object *samp, 370 GLint param) 371 { 372 if (samp->MinFilter == param) 373 return GL_FALSE; 374 375 switch (param) { 376 case GL_NEAREST: 377 case GL_LINEAR: 378 case GL_NEAREST_MIPMAP_NEAREST: 379 case GL_LINEAR_MIPMAP_NEAREST: 380 case GL_NEAREST_MIPMAP_LINEAR: 381 case GL_LINEAR_MIPMAP_LINEAR: 382 flush(ctx); 383 samp->MinFilter = param; 384 return GL_TRUE; 385 default: 386 return INVALID_PARAM; 387 } 388 } 389 390 391 static GLuint 392 set_sampler_mag_filter(struct gl_context *ctx, struct gl_sampler_object *samp, 393 GLint param) 394 { 395 if (samp->MagFilter == param) 396 return GL_FALSE; 397 398 switch (param) { 399 case GL_NEAREST: 400 case GL_LINEAR: 401 flush(ctx); 402 samp->MagFilter = param; 403 return GL_TRUE; 404 default: 405 return INVALID_PARAM; 406 } 407 } 408 409 410 static GLuint 411 set_sampler_lod_bias(struct gl_context *ctx, struct gl_sampler_object *samp, 412 GLfloat param) 413 { 414 if (samp->LodBias == param) 415 return GL_FALSE; 416 417 flush(ctx); 418 samp->LodBias = param; 419 return GL_TRUE; 420 } 421 422 423 static GLuint 424 set_sampler_border_colorf(struct gl_context *ctx, 425 struct gl_sampler_object *samp, 426 const GLfloat params[4]) 427 { 428 flush(ctx); 429 samp->BorderColor.f[RCOMP] = params[0]; 430 samp->BorderColor.f[GCOMP] = params[1]; 431 samp->BorderColor.f[BCOMP] = params[2]; 432 samp->BorderColor.f[ACOMP] = params[3]; 433 return GL_TRUE; 434 } 435 436 437 static GLuint 438 set_sampler_border_colori(struct gl_context *ctx, 439 struct gl_sampler_object *samp, 440 const GLint params[4]) 441 { 442 flush(ctx); 443 samp->BorderColor.i[RCOMP] = params[0]; 444 samp->BorderColor.i[GCOMP] = params[1]; 445 samp->BorderColor.i[BCOMP] = params[2]; 446 samp->BorderColor.i[ACOMP] = params[3]; 447 return GL_TRUE; 448 } 449 450 451 static GLuint 452 set_sampler_border_colorui(struct gl_context *ctx, 453 struct gl_sampler_object *samp, 454 const GLuint params[4]) 455 { 456 flush(ctx); 457 samp->BorderColor.ui[RCOMP] = params[0]; 458 samp->BorderColor.ui[GCOMP] = params[1]; 459 samp->BorderColor.ui[BCOMP] = params[2]; 460 samp->BorderColor.ui[ACOMP] = params[3]; 461 return GL_TRUE; 462 } 463 464 465 static GLuint 466 set_sampler_min_lod(struct gl_context *ctx, struct gl_sampler_object *samp, 467 GLfloat param) 468 { 469 if (samp->MinLod == param) 470 return GL_FALSE; 471 472 flush(ctx); 473 samp->MinLod = param; 474 return GL_TRUE; 475 } 476 477 478 static GLuint 479 set_sampler_max_lod(struct gl_context *ctx, struct gl_sampler_object *samp, 480 GLfloat param) 481 { 482 if (samp->MaxLod == param) 483 return GL_FALSE; 484 485 flush(ctx); 486 samp->MaxLod = param; 487 return GL_TRUE; 488 } 489 490 491 static GLuint 492 set_sampler_compare_mode(struct gl_context *ctx, 493 struct gl_sampler_object *samp, GLint param) 494 { 495 if (!ctx->Extensions.ARB_shadow) 496 return INVALID_PNAME; 497 498 if (samp->CompareMode == param) 499 return GL_FALSE; 500 501 if (param == GL_NONE || 502 param == GL_COMPARE_R_TO_TEXTURE_ARB) { 503 flush(ctx); 504 samp->CompareMode = param; 505 return GL_TRUE; 506 } 507 508 return INVALID_PARAM; 509 } 510 511 512 static GLuint 513 set_sampler_compare_func(struct gl_context *ctx, 514 struct gl_sampler_object *samp, GLint param) 515 { 516 if (!ctx->Extensions.ARB_shadow) 517 return INVALID_PNAME; 518 519 if (samp->CompareFunc == param) 520 return GL_FALSE; 521 522 switch (param) { 523 case GL_LEQUAL: 524 case GL_GEQUAL: 525 flush(ctx); 526 samp->CompareFunc = param; 527 return GL_TRUE; 528 case GL_EQUAL: 529 case GL_NOTEQUAL: 530 case GL_LESS: 531 case GL_GREATER: 532 case GL_ALWAYS: 533 case GL_NEVER: 534 if (ctx->Extensions.EXT_shadow_funcs) { 535 flush(ctx); 536 samp->CompareFunc = param; 537 return GL_TRUE; 538 } 539 /* fall-through */ 540 default: 541 return INVALID_PARAM; 542 } 543 } 544 545 546 static GLuint 547 set_sampler_max_anisotropy(struct gl_context *ctx, 548 struct gl_sampler_object *samp, GLfloat param) 549 { 550 if (!ctx->Extensions.EXT_texture_filter_anisotropic) 551 return INVALID_PNAME; 552 553 if (samp->MaxAnisotropy == param) 554 return GL_FALSE; 555 556 if (param < 1.0) 557 return INVALID_VALUE; 558 559 flush(ctx); 560 /* clamp to max, that's what NVIDIA does */ 561 samp->MaxAnisotropy = MIN2(param, ctx->Const.MaxTextureMaxAnisotropy); 562 return GL_TRUE; 563 } 564 565 566 static GLuint 567 set_sampler_cube_map_seamless(struct gl_context *ctx, 568 struct gl_sampler_object *samp, GLboolean param) 569 { 570 if (!ctx->Extensions.AMD_seamless_cubemap_per_texture) 571 return INVALID_PNAME; 572 573 if (samp->CubeMapSeamless == param) 574 return GL_FALSE; 575 576 if (param != GL_TRUE && param != GL_FALSE) 577 return INVALID_VALUE; 578 579 flush(ctx); 580 samp->CubeMapSeamless = param; 581 return GL_TRUE; 582 } 583 584 static GLuint 585 set_sampler_srgb_decode(struct gl_context *ctx, 586 struct gl_sampler_object *samp, GLenum param) 587 { 588 if (!ctx->Extensions.EXT_texture_sRGB_decode) 589 return INVALID_PNAME; 590 591 if (samp->sRGBDecode == param) 592 return GL_FALSE; 593 594 if (param != GL_DECODE_EXT && param != GL_SKIP_DECODE_EXT) 595 return INVALID_VALUE; 596 597 flush(ctx); 598 samp->sRGBDecode = param; 599 return GL_TRUE; 600 } 601 602 void GLAPIENTRY 603 _mesa_SamplerParameteri(GLuint sampler, GLenum pname, GLint param) 604 { 605 struct gl_sampler_object *sampObj; 606 GLuint res; 607 GET_CURRENT_CONTEXT(ctx); 608 609 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 610 if (!sampObj) { 611 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameteri(sampler %u)", 612 sampler); 613 return; 614 } 615 616 switch (pname) { 617 case GL_TEXTURE_WRAP_S: 618 res = set_sampler_wrap_s(ctx, sampObj, param); 619 break; 620 case GL_TEXTURE_WRAP_T: 621 res = set_sampler_wrap_t(ctx, sampObj, param); 622 break; 623 case GL_TEXTURE_WRAP_R: 624 res = set_sampler_wrap_r(ctx, sampObj, param); 625 break; 626 case GL_TEXTURE_MIN_FILTER: 627 res = set_sampler_min_filter(ctx, sampObj, param); 628 break; 629 case GL_TEXTURE_MAG_FILTER: 630 res = set_sampler_mag_filter(ctx, sampObj, param); 631 break; 632 case GL_TEXTURE_MIN_LOD: 633 res = set_sampler_min_lod(ctx, sampObj, (GLfloat) param); 634 break; 635 case GL_TEXTURE_MAX_LOD: 636 res = set_sampler_max_lod(ctx, sampObj, (GLfloat) param); 637 break; 638 case GL_TEXTURE_LOD_BIAS: 639 res = set_sampler_lod_bias(ctx, sampObj, (GLfloat) param); 640 break; 641 case GL_TEXTURE_COMPARE_MODE: 642 res = set_sampler_compare_mode(ctx, sampObj, param); 643 break; 644 case GL_TEXTURE_COMPARE_FUNC: 645 res = set_sampler_compare_func(ctx, sampObj, param); 646 break; 647 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 648 res = set_sampler_max_anisotropy(ctx, sampObj, (GLfloat) param); 649 break; 650 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 651 res = set_sampler_cube_map_seamless(ctx, sampObj, param); 652 break; 653 case GL_TEXTURE_SRGB_DECODE_EXT: 654 res = set_sampler_srgb_decode(ctx, sampObj, param); 655 break; 656 case GL_TEXTURE_BORDER_COLOR: 657 /* fall-through */ 658 default: 659 res = INVALID_PNAME; 660 } 661 662 switch (res) { 663 case GL_FALSE: 664 /* no change */ 665 break; 666 case GL_TRUE: 667 /* state change - we do nothing special at this time */ 668 break; 669 case INVALID_PNAME: 670 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameteri(pname=%s)\n", 671 _mesa_lookup_enum_by_nr(pname)); 672 break; 673 case INVALID_PARAM: 674 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameteri(param=%d)\n", 675 param); 676 break; 677 case INVALID_VALUE: 678 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameteri(param=%d)\n", 679 param); 680 break; 681 default: 682 ; 683 } 684 } 685 686 687 static void GLAPIENTRY 688 _mesa_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) 689 { 690 struct gl_sampler_object *sampObj; 691 GLuint res; 692 GET_CURRENT_CONTEXT(ctx); 693 694 ASSERT_OUTSIDE_BEGIN_END(ctx); 695 696 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 697 if (!sampObj) { 698 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterf(sampler %u)", 699 sampler); 700 return; 701 } 702 703 switch (pname) { 704 case GL_TEXTURE_WRAP_S: 705 res = set_sampler_wrap_s(ctx, sampObj, (GLint) param); 706 break; 707 case GL_TEXTURE_WRAP_T: 708 res = set_sampler_wrap_t(ctx, sampObj, (GLint) param); 709 break; 710 case GL_TEXTURE_WRAP_R: 711 res = set_sampler_wrap_r(ctx, sampObj, (GLint) param); 712 break; 713 case GL_TEXTURE_MIN_FILTER: 714 res = set_sampler_min_filter(ctx, sampObj, (GLint) param); 715 break; 716 case GL_TEXTURE_MAG_FILTER: 717 res = set_sampler_mag_filter(ctx, sampObj, (GLint) param); 718 break; 719 case GL_TEXTURE_MIN_LOD: 720 res = set_sampler_min_lod(ctx, sampObj, param); 721 break; 722 case GL_TEXTURE_MAX_LOD: 723 res = set_sampler_max_lod(ctx, sampObj, param); 724 break; 725 case GL_TEXTURE_LOD_BIAS: 726 res = set_sampler_lod_bias(ctx, sampObj, param); 727 break; 728 case GL_TEXTURE_COMPARE_MODE: 729 res = set_sampler_compare_mode(ctx, sampObj, (GLint) param); 730 break; 731 case GL_TEXTURE_COMPARE_FUNC: 732 res = set_sampler_compare_func(ctx, sampObj, (GLint) param); 733 break; 734 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 735 res = set_sampler_max_anisotropy(ctx, sampObj, param); 736 break; 737 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 738 res = set_sampler_cube_map_seamless(ctx, sampObj, (GLboolean) param); 739 break; 740 case GL_TEXTURE_SRGB_DECODE_EXT: 741 res = set_sampler_srgb_decode(ctx, sampObj, (GLenum) param); 742 break; 743 case GL_TEXTURE_BORDER_COLOR: 744 /* fall-through */ 745 default: 746 res = INVALID_PNAME; 747 } 748 749 switch (res) { 750 case GL_FALSE: 751 /* no change */ 752 break; 753 case GL_TRUE: 754 /* state change - we do nothing special at this time */ 755 break; 756 case INVALID_PNAME: 757 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterf(pname=%s)\n", 758 _mesa_lookup_enum_by_nr(pname)); 759 break; 760 case INVALID_PARAM: 761 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterf(param=%f)\n", 762 param); 763 break; 764 case INVALID_VALUE: 765 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterf(param=%f)\n", 766 param); 767 break; 768 default: 769 ; 770 } 771 } 772 773 static void GLAPIENTRY 774 _mesa_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *params) 775 { 776 struct gl_sampler_object *sampObj; 777 GLuint res; 778 GET_CURRENT_CONTEXT(ctx); 779 780 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 781 if (!sampObj) { 782 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameteriv(sampler %u)", 783 sampler); 784 return; 785 } 786 787 switch (pname) { 788 case GL_TEXTURE_WRAP_S: 789 res = set_sampler_wrap_s(ctx, sampObj, params[0]); 790 break; 791 case GL_TEXTURE_WRAP_T: 792 res = set_sampler_wrap_t(ctx, sampObj, params[0]); 793 break; 794 case GL_TEXTURE_WRAP_R: 795 res = set_sampler_wrap_r(ctx, sampObj, params[0]); 796 break; 797 case GL_TEXTURE_MIN_FILTER: 798 res = set_sampler_min_filter(ctx, sampObj, params[0]); 799 break; 800 case GL_TEXTURE_MAG_FILTER: 801 res = set_sampler_mag_filter(ctx, sampObj, params[0]); 802 break; 803 case GL_TEXTURE_MIN_LOD: 804 res = set_sampler_min_lod(ctx, sampObj, (GLfloat) params[0]); 805 break; 806 case GL_TEXTURE_MAX_LOD: 807 res = set_sampler_max_lod(ctx, sampObj, (GLfloat) params[0]); 808 break; 809 case GL_TEXTURE_LOD_BIAS: 810 res = set_sampler_lod_bias(ctx, sampObj, (GLfloat) params[0]); 811 break; 812 case GL_TEXTURE_COMPARE_MODE: 813 res = set_sampler_compare_mode(ctx, sampObj, params[0]); 814 break; 815 case GL_TEXTURE_COMPARE_FUNC: 816 res = set_sampler_compare_func(ctx, sampObj, params[0]); 817 break; 818 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 819 res = set_sampler_max_anisotropy(ctx, sampObj, (GLfloat) params[0]); 820 break; 821 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 822 res = set_sampler_cube_map_seamless(ctx, sampObj, params[0]); 823 break; 824 case GL_TEXTURE_SRGB_DECODE_EXT: 825 res = set_sampler_srgb_decode(ctx, sampObj, params[0]); 826 break; 827 case GL_TEXTURE_BORDER_COLOR: 828 { 829 GLfloat c[4]; 830 c[0] = INT_TO_FLOAT(params[0]); 831 c[1] = INT_TO_FLOAT(params[1]); 832 c[2] = INT_TO_FLOAT(params[2]); 833 c[3] = INT_TO_FLOAT(params[3]); 834 res = set_sampler_border_colorf(ctx, sampObj, c); 835 } 836 break; 837 default: 838 res = INVALID_PNAME; 839 } 840 841 switch (res) { 842 case GL_FALSE: 843 /* no change */ 844 break; 845 case GL_TRUE: 846 /* state change - we do nothing special at this time */ 847 break; 848 case INVALID_PNAME: 849 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameteriv(pname=%s)\n", 850 _mesa_lookup_enum_by_nr(pname)); 851 break; 852 case INVALID_PARAM: 853 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameteriv(param=%d)\n", 854 params[0]); 855 break; 856 case INVALID_VALUE: 857 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameteriv(param=%d)\n", 858 params[0]); 859 break; 860 default: 861 ; 862 } 863 } 864 865 static void GLAPIENTRY 866 _mesa_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *params) 867 { 868 struct gl_sampler_object *sampObj; 869 GLuint res; 870 GET_CURRENT_CONTEXT(ctx); 871 872 ASSERT_OUTSIDE_BEGIN_END(ctx); 873 874 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 875 if (!sampObj) { 876 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterfv(sampler %u)", 877 sampler); 878 return; 879 } 880 881 switch (pname) { 882 case GL_TEXTURE_WRAP_S: 883 res = set_sampler_wrap_s(ctx, sampObj, (GLint) params[0]); 884 break; 885 case GL_TEXTURE_WRAP_T: 886 res = set_sampler_wrap_t(ctx, sampObj, (GLint) params[0]); 887 break; 888 case GL_TEXTURE_WRAP_R: 889 res = set_sampler_wrap_r(ctx, sampObj, (GLint) params[0]); 890 break; 891 case GL_TEXTURE_MIN_FILTER: 892 res = set_sampler_min_filter(ctx, sampObj, (GLint) params[0]); 893 break; 894 case GL_TEXTURE_MAG_FILTER: 895 res = set_sampler_mag_filter(ctx, sampObj, (GLint) params[0]); 896 break; 897 case GL_TEXTURE_MIN_LOD: 898 res = set_sampler_min_lod(ctx, sampObj, params[0]); 899 break; 900 case GL_TEXTURE_MAX_LOD: 901 res = set_sampler_max_lod(ctx, sampObj, params[0]); 902 break; 903 case GL_TEXTURE_LOD_BIAS: 904 res = set_sampler_lod_bias(ctx, sampObj, params[0]); 905 break; 906 case GL_TEXTURE_COMPARE_MODE: 907 res = set_sampler_compare_mode(ctx, sampObj, (GLint) params[0]); 908 break; 909 case GL_TEXTURE_COMPARE_FUNC: 910 res = set_sampler_compare_func(ctx, sampObj, (GLint) params[0]); 911 break; 912 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 913 res = set_sampler_max_anisotropy(ctx, sampObj, params[0]); 914 break; 915 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 916 res = set_sampler_cube_map_seamless(ctx, sampObj, (GLboolean) params[0]); 917 break; 918 case GL_TEXTURE_SRGB_DECODE_EXT: 919 res = set_sampler_srgb_decode(ctx, sampObj, (GLenum) params[0]); 920 break; 921 case GL_TEXTURE_BORDER_COLOR: 922 res = set_sampler_border_colorf(ctx, sampObj, params); 923 break; 924 default: 925 res = INVALID_PNAME; 926 } 927 928 switch (res) { 929 case GL_FALSE: 930 /* no change */ 931 break; 932 case GL_TRUE: 933 /* state change - we do nothing special at this time */ 934 break; 935 case INVALID_PNAME: 936 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterfv(pname=%s)\n", 937 _mesa_lookup_enum_by_nr(pname)); 938 break; 939 case INVALID_PARAM: 940 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterfv(param=%f)\n", 941 params[0]); 942 break; 943 case INVALID_VALUE: 944 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterfv(param=%f)\n", 945 params[0]); 946 break; 947 default: 948 ; 949 } 950 } 951 952 static void GLAPIENTRY 953 _mesa_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *params) 954 { 955 struct gl_sampler_object *sampObj; 956 GLuint res; 957 GET_CURRENT_CONTEXT(ctx); 958 959 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 960 if (!sampObj) { 961 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterIiv(sampler %u)", 962 sampler); 963 return; 964 } 965 966 switch (pname) { 967 case GL_TEXTURE_WRAP_S: 968 res = set_sampler_wrap_s(ctx, sampObj, params[0]); 969 break; 970 case GL_TEXTURE_WRAP_T: 971 res = set_sampler_wrap_t(ctx, sampObj, params[0]); 972 break; 973 case GL_TEXTURE_WRAP_R: 974 res = set_sampler_wrap_r(ctx, sampObj, params[0]); 975 break; 976 case GL_TEXTURE_MIN_FILTER: 977 res = set_sampler_min_filter(ctx, sampObj, params[0]); 978 break; 979 case GL_TEXTURE_MAG_FILTER: 980 res = set_sampler_mag_filter(ctx, sampObj, params[0]); 981 break; 982 case GL_TEXTURE_MIN_LOD: 983 res = set_sampler_min_lod(ctx, sampObj, (GLfloat) params[0]); 984 break; 985 case GL_TEXTURE_MAX_LOD: 986 res = set_sampler_max_lod(ctx, sampObj, (GLfloat) params[0]); 987 break; 988 case GL_TEXTURE_LOD_BIAS: 989 res = set_sampler_lod_bias(ctx, sampObj, (GLfloat) params[0]); 990 break; 991 case GL_TEXTURE_COMPARE_MODE: 992 res = set_sampler_compare_mode(ctx, sampObj, params[0]); 993 break; 994 case GL_TEXTURE_COMPARE_FUNC: 995 res = set_sampler_compare_func(ctx, sampObj, params[0]); 996 break; 997 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 998 res = set_sampler_max_anisotropy(ctx, sampObj, (GLfloat) params[0]); 999 break; 1000 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1001 res = set_sampler_cube_map_seamless(ctx, sampObj, params[0]); 1002 break; 1003 case GL_TEXTURE_SRGB_DECODE_EXT: 1004 res = set_sampler_srgb_decode(ctx, sampObj, (GLenum) params[0]); 1005 break; 1006 case GL_TEXTURE_BORDER_COLOR: 1007 res = set_sampler_border_colori(ctx, sampObj, params); 1008 break; 1009 default: 1010 res = INVALID_PNAME; 1011 } 1012 1013 switch (res) { 1014 case GL_FALSE: 1015 /* no change */ 1016 break; 1017 case GL_TRUE: 1018 /* state change - we do nothing special at this time */ 1019 break; 1020 case INVALID_PNAME: 1021 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterIiv(pname=%s)\n", 1022 _mesa_lookup_enum_by_nr(pname)); 1023 break; 1024 case INVALID_PARAM: 1025 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterIiv(param=%d)\n", 1026 params[0]); 1027 break; 1028 case INVALID_VALUE: 1029 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterIiv(param=%d)\n", 1030 params[0]); 1031 break; 1032 default: 1033 ; 1034 } 1035 } 1036 1037 1038 static void GLAPIENTRY 1039 _mesa_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *params) 1040 { 1041 struct gl_sampler_object *sampObj; 1042 GLuint res; 1043 GET_CURRENT_CONTEXT(ctx); 1044 1045 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 1046 if (!sampObj) { 1047 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterIuiv(sampler %u)", 1048 sampler); 1049 return; 1050 } 1051 1052 switch (pname) { 1053 case GL_TEXTURE_WRAP_S: 1054 res = set_sampler_wrap_s(ctx, sampObj, params[0]); 1055 break; 1056 case GL_TEXTURE_WRAP_T: 1057 res = set_sampler_wrap_t(ctx, sampObj, params[0]); 1058 break; 1059 case GL_TEXTURE_WRAP_R: 1060 res = set_sampler_wrap_r(ctx, sampObj, params[0]); 1061 break; 1062 case GL_TEXTURE_MIN_FILTER: 1063 res = set_sampler_min_filter(ctx, sampObj, params[0]); 1064 break; 1065 case GL_TEXTURE_MAG_FILTER: 1066 res = set_sampler_mag_filter(ctx, sampObj, params[0]); 1067 break; 1068 case GL_TEXTURE_MIN_LOD: 1069 res = set_sampler_min_lod(ctx, sampObj, (GLfloat) params[0]); 1070 break; 1071 case GL_TEXTURE_MAX_LOD: 1072 res = set_sampler_max_lod(ctx, sampObj, (GLfloat) params[0]); 1073 break; 1074 case GL_TEXTURE_LOD_BIAS: 1075 res = set_sampler_lod_bias(ctx, sampObj, (GLfloat) params[0]); 1076 break; 1077 case GL_TEXTURE_COMPARE_MODE: 1078 res = set_sampler_compare_mode(ctx, sampObj, params[0]); 1079 break; 1080 case GL_TEXTURE_COMPARE_FUNC: 1081 res = set_sampler_compare_func(ctx, sampObj, params[0]); 1082 break; 1083 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 1084 res = set_sampler_max_anisotropy(ctx, sampObj, (GLfloat) params[0]); 1085 break; 1086 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1087 res = set_sampler_cube_map_seamless(ctx, sampObj, params[0]); 1088 break; 1089 case GL_TEXTURE_SRGB_DECODE_EXT: 1090 res = set_sampler_srgb_decode(ctx, sampObj, (GLenum) params[0]); 1091 break; 1092 case GL_TEXTURE_BORDER_COLOR: 1093 res = set_sampler_border_colorui(ctx, sampObj, params); 1094 break; 1095 default: 1096 res = INVALID_PNAME; 1097 } 1098 1099 switch (res) { 1100 case GL_FALSE: 1101 /* no change */ 1102 break; 1103 case GL_TRUE: 1104 /* state change - we do nothing special at this time */ 1105 break; 1106 case INVALID_PNAME: 1107 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterIuiv(pname=%s)\n", 1108 _mesa_lookup_enum_by_nr(pname)); 1109 break; 1110 case INVALID_PARAM: 1111 _mesa_error(ctx, GL_INVALID_ENUM, "glSamplerParameterIuiv(param=%u)\n", 1112 params[0]); 1113 break; 1114 case INVALID_VALUE: 1115 _mesa_error(ctx, GL_INVALID_VALUE, "glSamplerParameterIuiv(param=%u)\n", 1116 params[0]); 1117 break; 1118 default: 1119 ; 1120 } 1121 } 1122 1123 1124 static void GLAPIENTRY 1125 _mesa_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params) 1126 { 1127 struct gl_sampler_object *sampObj; 1128 GET_CURRENT_CONTEXT(ctx); 1129 1130 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 1131 if (!sampObj) { 1132 _mesa_error(ctx, GL_INVALID_VALUE, "glGetSamplerParameteriv(sampler %u)", 1133 sampler); 1134 return; 1135 } 1136 1137 switch (pname) { 1138 case GL_TEXTURE_WRAP_S: 1139 *params = sampObj->WrapS; 1140 break; 1141 case GL_TEXTURE_WRAP_T: 1142 *params = sampObj->WrapT; 1143 break; 1144 case GL_TEXTURE_WRAP_R: 1145 *params = sampObj->WrapR; 1146 break; 1147 case GL_TEXTURE_MIN_FILTER: 1148 *params = sampObj->MinFilter; 1149 break; 1150 case GL_TEXTURE_MAG_FILTER: 1151 *params = sampObj->MagFilter; 1152 break; 1153 case GL_TEXTURE_MIN_LOD: 1154 *params = (GLint) sampObj->MinLod; 1155 break; 1156 case GL_TEXTURE_MAX_LOD: 1157 *params = (GLint) sampObj->MaxLod; 1158 break; 1159 case GL_TEXTURE_LOD_BIAS: 1160 *params = (GLint) sampObj->LodBias; 1161 break; 1162 case GL_TEXTURE_COMPARE_MODE: 1163 if (!ctx->Extensions.ARB_shadow) 1164 goto invalid_pname; 1165 *params = sampObj->CompareMode; 1166 break; 1167 case GL_TEXTURE_COMPARE_FUNC: 1168 if (!ctx->Extensions.ARB_shadow) 1169 goto invalid_pname; 1170 *params = sampObj->CompareFunc; 1171 break; 1172 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 1173 *params = (GLint) sampObj->MaxAnisotropy; 1174 break; 1175 case GL_TEXTURE_BORDER_COLOR: 1176 params[0] = FLOAT_TO_INT(sampObj->BorderColor.f[0]); 1177 params[1] = FLOAT_TO_INT(sampObj->BorderColor.f[1]); 1178 params[2] = FLOAT_TO_INT(sampObj->BorderColor.f[2]); 1179 params[3] = FLOAT_TO_INT(sampObj->BorderColor.f[3]); 1180 break; 1181 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1182 if (!ctx->Extensions.AMD_seamless_cubemap_per_texture) 1183 goto invalid_pname; 1184 *params = sampObj->CubeMapSeamless; 1185 break; 1186 case GL_TEXTURE_SRGB_DECODE_EXT: 1187 if (!ctx->Extensions.EXT_texture_sRGB_decode) 1188 goto invalid_pname; 1189 *params = (GLenum) sampObj->sRGBDecode; 1190 break; 1191 default: 1192 goto invalid_pname; 1193 } 1194 return; 1195 1196 invalid_pname: 1197 _mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameteriv(pname=%s)", 1198 _mesa_lookup_enum_by_nr(pname)); 1199 } 1200 1201 1202 static void GLAPIENTRY 1203 _mesa_GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params) 1204 { 1205 struct gl_sampler_object *sampObj; 1206 GET_CURRENT_CONTEXT(ctx); 1207 1208 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 1209 if (!sampObj) { 1210 _mesa_error(ctx, GL_INVALID_VALUE, "glGetSamplerParameterfv(sampler %u)", 1211 sampler); 1212 return; 1213 } 1214 1215 switch (pname) { 1216 case GL_TEXTURE_WRAP_S: 1217 *params = (GLfloat) sampObj->WrapS; 1218 break; 1219 case GL_TEXTURE_WRAP_T: 1220 *params = (GLfloat) sampObj->WrapT; 1221 break; 1222 case GL_TEXTURE_WRAP_R: 1223 *params = (GLfloat) sampObj->WrapR; 1224 break; 1225 case GL_TEXTURE_MIN_FILTER: 1226 *params = (GLfloat) sampObj->MinFilter; 1227 break; 1228 case GL_TEXTURE_MAG_FILTER: 1229 *params = (GLfloat) sampObj->MagFilter; 1230 break; 1231 case GL_TEXTURE_MIN_LOD: 1232 *params = sampObj->MinLod; 1233 break; 1234 case GL_TEXTURE_MAX_LOD: 1235 *params = sampObj->MaxLod; 1236 break; 1237 case GL_TEXTURE_LOD_BIAS: 1238 *params = sampObj->LodBias; 1239 break; 1240 case GL_TEXTURE_COMPARE_MODE: 1241 if (!ctx->Extensions.ARB_shadow) 1242 goto invalid_pname; 1243 *params = (GLfloat) sampObj->CompareMode; 1244 break; 1245 case GL_TEXTURE_COMPARE_FUNC: 1246 if (!ctx->Extensions.ARB_shadow) 1247 goto invalid_pname; 1248 *params = (GLfloat) sampObj->CompareFunc; 1249 break; 1250 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 1251 *params = sampObj->MaxAnisotropy; 1252 break; 1253 case GL_TEXTURE_BORDER_COLOR: 1254 params[0] = sampObj->BorderColor.f[0]; 1255 params[1] = sampObj->BorderColor.f[1]; 1256 params[2] = sampObj->BorderColor.f[2]; 1257 params[3] = sampObj->BorderColor.f[3]; 1258 break; 1259 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1260 if (!ctx->Extensions.AMD_seamless_cubemap_per_texture) 1261 goto invalid_pname; 1262 *params = (GLfloat) sampObj->CubeMapSeamless; 1263 break; 1264 case GL_TEXTURE_SRGB_DECODE_EXT: 1265 if (!ctx->Extensions.EXT_texture_sRGB_decode) 1266 goto invalid_pname; 1267 *params = (GLfloat) sampObj->sRGBDecode; 1268 break; 1269 default: 1270 goto invalid_pname; 1271 } 1272 return; 1273 1274 invalid_pname: 1275 _mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameterfv(pname=%s)", 1276 _mesa_lookup_enum_by_nr(pname)); 1277 } 1278 1279 1280 static void GLAPIENTRY 1281 _mesa_GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params) 1282 { 1283 struct gl_sampler_object *sampObj; 1284 GET_CURRENT_CONTEXT(ctx); 1285 1286 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 1287 if (!sampObj) { 1288 _mesa_error(ctx, GL_INVALID_VALUE, 1289 "glGetSamplerParameterIiv(sampler %u)", 1290 sampler); 1291 return; 1292 } 1293 1294 switch (pname) { 1295 case GL_TEXTURE_WRAP_S: 1296 *params = sampObj->WrapS; 1297 break; 1298 case GL_TEXTURE_WRAP_T: 1299 *params = sampObj->WrapT; 1300 break; 1301 case GL_TEXTURE_WRAP_R: 1302 *params = sampObj->WrapR; 1303 break; 1304 case GL_TEXTURE_MIN_FILTER: 1305 *params = sampObj->MinFilter; 1306 break; 1307 case GL_TEXTURE_MAG_FILTER: 1308 *params = sampObj->MagFilter; 1309 break; 1310 case GL_TEXTURE_MIN_LOD: 1311 *params = (GLint) sampObj->MinLod; 1312 break; 1313 case GL_TEXTURE_MAX_LOD: 1314 *params = (GLint) sampObj->MaxLod; 1315 break; 1316 case GL_TEXTURE_LOD_BIAS: 1317 *params = (GLint) sampObj->LodBias; 1318 break; 1319 case GL_TEXTURE_COMPARE_MODE: 1320 if (!ctx->Extensions.ARB_shadow) 1321 goto invalid_pname; 1322 *params = sampObj->CompareMode; 1323 break; 1324 case GL_TEXTURE_COMPARE_FUNC: 1325 if (!ctx->Extensions.ARB_shadow) 1326 goto invalid_pname; 1327 *params = sampObj->CompareFunc; 1328 break; 1329 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 1330 *params = (GLint) sampObj->MaxAnisotropy; 1331 break; 1332 case GL_TEXTURE_BORDER_COLOR: 1333 params[0] = sampObj->BorderColor.i[0]; 1334 params[1] = sampObj->BorderColor.i[1]; 1335 params[2] = sampObj->BorderColor.i[2]; 1336 params[3] = sampObj->BorderColor.i[3]; 1337 break; 1338 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1339 if (!ctx->Extensions.AMD_seamless_cubemap_per_texture) 1340 goto invalid_pname; 1341 *params = sampObj->CubeMapSeamless; 1342 break; 1343 case GL_TEXTURE_SRGB_DECODE_EXT: 1344 if (!ctx->Extensions.EXT_texture_sRGB_decode) 1345 goto invalid_pname; 1346 *params = (GLenum) sampObj->sRGBDecode; 1347 break; 1348 default: 1349 goto invalid_pname; 1350 } 1351 return; 1352 1353 invalid_pname: 1354 _mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameterIiv(pname=%s)", 1355 _mesa_lookup_enum_by_nr(pname)); 1356 } 1357 1358 1359 static void GLAPIENTRY 1360 _mesa_GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params) 1361 { 1362 struct gl_sampler_object *sampObj; 1363 GET_CURRENT_CONTEXT(ctx); 1364 1365 sampObj = _mesa_lookup_samplerobj(ctx, sampler); 1366 if (!sampObj) { 1367 _mesa_error(ctx, GL_INVALID_VALUE, 1368 "glGetSamplerParameterIuiv(sampler %u)", 1369 sampler); 1370 return; 1371 } 1372 1373 switch (pname) { 1374 case GL_TEXTURE_WRAP_S: 1375 *params = sampObj->WrapS; 1376 break; 1377 case GL_TEXTURE_WRAP_T: 1378 *params = sampObj->WrapT; 1379 break; 1380 case GL_TEXTURE_WRAP_R: 1381 *params = sampObj->WrapR; 1382 break; 1383 case GL_TEXTURE_MIN_FILTER: 1384 *params = sampObj->MinFilter; 1385 break; 1386 case GL_TEXTURE_MAG_FILTER: 1387 *params = sampObj->MagFilter; 1388 break; 1389 case GL_TEXTURE_MIN_LOD: 1390 *params = (GLuint) sampObj->MinLod; 1391 break; 1392 case GL_TEXTURE_MAX_LOD: 1393 *params = (GLuint) sampObj->MaxLod; 1394 break; 1395 case GL_TEXTURE_LOD_BIAS: 1396 *params = (GLuint) sampObj->LodBias; 1397 break; 1398 case GL_TEXTURE_COMPARE_MODE: 1399 if (!ctx->Extensions.ARB_shadow) 1400 goto invalid_pname; 1401 *params = sampObj->CompareMode; 1402 break; 1403 case GL_TEXTURE_COMPARE_FUNC: 1404 if (!ctx->Extensions.ARB_shadow) 1405 goto invalid_pname; 1406 *params = sampObj->CompareFunc; 1407 break; 1408 case GL_TEXTURE_MAX_ANISOTROPY_EXT: 1409 *params = (GLuint) sampObj->MaxAnisotropy; 1410 break; 1411 case GL_TEXTURE_BORDER_COLOR: 1412 params[0] = sampObj->BorderColor.ui[0]; 1413 params[1] = sampObj->BorderColor.ui[1]; 1414 params[2] = sampObj->BorderColor.ui[2]; 1415 params[3] = sampObj->BorderColor.ui[3]; 1416 break; 1417 case GL_TEXTURE_CUBE_MAP_SEAMLESS: 1418 if (!ctx->Extensions.AMD_seamless_cubemap_per_texture) 1419 goto invalid_pname; 1420 *params = sampObj->CubeMapSeamless; 1421 break; 1422 case GL_TEXTURE_SRGB_DECODE_EXT: 1423 if (!ctx->Extensions.EXT_texture_sRGB_decode) 1424 goto invalid_pname; 1425 *params = (GLenum) sampObj->sRGBDecode; 1426 break; 1427 default: 1428 goto invalid_pname; 1429 } 1430 return; 1431 1432 invalid_pname: 1433 _mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameterIuiv(pname=%s)", 1434 _mesa_lookup_enum_by_nr(pname)); 1435 } 1436 1437 1438 void 1439 _mesa_init_sampler_object_functions(struct dd_function_table *driver) 1440 { 1441 driver->NewSamplerObject = _mesa_new_sampler_object; 1442 driver->DeleteSamplerObject = _mesa_delete_sampler_object; 1443 } 1444 1445 1446 void 1447 _mesa_init_sampler_object_dispatch(struct _glapi_table *disp) 1448 { 1449 SET_GenSamplers(disp, _mesa_GenSamplers); 1450 SET_DeleteSamplers(disp, _mesa_DeleteSamplers); 1451 SET_IsSampler(disp, _mesa_IsSampler); 1452 SET_BindSampler(disp, _mesa_BindSampler); 1453 SET_SamplerParameteri(disp, _mesa_SamplerParameteri); 1454 SET_SamplerParameterf(disp, _mesa_SamplerParameterf); 1455 SET_SamplerParameteriv(disp, _mesa_SamplerParameteriv); 1456 SET_SamplerParameterfv(disp, _mesa_SamplerParameterfv); 1457 SET_SamplerParameterIiv(disp, _mesa_SamplerParameterIiv); 1458 SET_SamplerParameterIuiv(disp, _mesa_SamplerParameterIuiv); 1459 SET_GetSamplerParameteriv(disp, _mesa_GetSamplerParameteriv); 1460 SET_GetSamplerParameterfv(disp, _mesa_GetSamplerParameterfv); 1461 SET_GetSamplerParameterIiv(disp, _mesa_GetSamplerParameterIiv); 1462 SET_GetSamplerParameterIuiv(disp, _mesa_GetSamplerParameterIuiv); 1463 } 1464
