projects / mesa.git / blob
? search:


4ce8c8593a9e73647b3c73a807975dadd5e98d10
[mesa.git] / src / mesa / main / texparam.c
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 texparam.c
28 *
29 * glTexParameter-related functions
30 */
31
32
33 #include "main/glheader.h"
34 #include "main/context.h"
35 #include "main/enums.h"
36 #include "main/colormac.h"
37 #include "main/macros.h"
38 #include "main/texcompress.h"
39 #include "main/texparam.h"
40 #include "main/teximage.h"
41 #include "main/texstate.h"
42 #include "shader/prog_instruction.h"
43
44
45 /**
46 * Check if a coordinate wrap mode is supported for the texture target.
47 * \return GL_TRUE if legal, GL_FALSE otherwise
48 */
49 static GLboolean
50 validate_texture_wrap_mode(GLcontext * ctx, GLenum target, GLenum wrap)
51 {
52 const struct gl_extensions * const e = & ctx->Extensions;
53
54 if (wrap == GL_CLAMP || wrap == GL_CLAMP_TO_EDGE ||
55 (wrap == GL_CLAMP_TO_BORDER && e->ARB_texture_border_clamp)) {
56 /* any texture target */
57 return GL_TRUE;
58 }
59 else if (target != GL_TEXTURE_RECTANGLE_NV &&
60 (wrap == GL_REPEAT ||
61 (wrap == GL_MIRRORED_REPEAT &&
62 e->ARB_texture_mirrored_repeat) ||
63 (wrap == GL_MIRROR_CLAMP_EXT &&
64 (e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp)) ||
65 (wrap == GL_MIRROR_CLAMP_TO_EDGE_EXT &&
66 (e->ATI_texture_mirror_once || e->EXT_texture_mirror_clamp)) ||
67 (wrap == GL_MIRROR_CLAMP_TO_BORDER_EXT &&
68 (e->EXT_texture_mirror_clamp)))) {
69 /* non-rectangle texture */
70 return GL_TRUE;
71 }
72
73 _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)", wrap );
74 return GL_FALSE;
75 }
76
77
78 /**
79 * Get current texture object for given target.
80 * Return NULL if any error.
81 */
82 static struct gl_texture_object *
83 get_texobj(GLcontext *ctx, GLenum target)
84 {
85 struct gl_texture_unit *texUnit;
86
87 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
88 _mesa_error(ctx, GL_INVALID_OPERATION, "glTexParameter(current unit)");
89 return NULL;
90 }
91
92 texUnit = _mesa_get_current_tex_unit(ctx);
93
94 switch (target) {
95 case GL_TEXTURE_1D:
96 return texUnit->CurrentTex[TEXTURE_1D_INDEX];
97 case GL_TEXTURE_2D:
98 return texUnit->CurrentTex[TEXTURE_2D_INDEX];
99 case GL_TEXTURE_3D:
100 return texUnit->CurrentTex[TEXTURE_3D_INDEX];
101 case GL_TEXTURE_CUBE_MAP:
102 if (ctx->Extensions.ARB_texture_cube_map) {
103 return texUnit->CurrentTex[TEXTURE_CUBE_INDEX];
104 }
105 break;
106 case GL_TEXTURE_RECTANGLE_NV:
107 if (ctx->Extensions.NV_texture_rectangle) {
108 return texUnit->CurrentTex[TEXTURE_RECT_INDEX];
109 }
110 break;
111 case GL_TEXTURE_1D_ARRAY_EXT:
112 if (ctx->Extensions.MESA_texture_array) {
113 return texUnit->CurrentTex[TEXTURE_1D_ARRAY_INDEX];
114 }
115 break;
116 case GL_TEXTURE_2D_ARRAY_EXT:
117 if (ctx->Extensions.MESA_texture_array) {
118 return texUnit->CurrentTex[TEXTURE_2D_ARRAY_INDEX];
119 }
120 break;
121 default:
122 ;
123 }
124
125 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(target)");
126 return NULL;
127 }
128
129
130 /**
131 * Convert GL_RED/GREEN/BLUE/ALPHA/ZERO/ONE to SWIZZLE_X/Y/Z/W/ZERO/ONE.
132 * \return -1 if error.
133 */
134 static GLint
135 comp_to_swizzle(GLenum comp)
136 {
137 switch (comp) {
138 case GL_RED:
139 return SWIZZLE_X;
140 case GL_GREEN:
141 return SWIZZLE_Y;
142 case GL_BLUE:
143 return SWIZZLE_Z;
144 case GL_ALPHA:
145 return SWIZZLE_W;
146 case GL_ZERO:
147 return SWIZZLE_ZERO;
148 case GL_ONE:
149 return SWIZZLE_ONE;
150 default:
151 return -1;
152 }
153 }
154
155
156 static void
157 set_swizzle_component(GLuint *swizzle, GLuint comp, GLuint swz)
158 {
159 ASSERT(comp < 4);
160 ASSERT(swz <= SWIZZLE_NIL);
161 {
162 GLuint mask = 0x7 << (3 * comp);
163 GLuint s = (*swizzle & ~mask) | (swz << (3 * comp));
164 *swizzle = s;
165 }
166 }
167
168
169 /**
170 * This is called just prior to changing any texture object state.
171 * Any pending rendering will be flushed out, we'll set the _NEW_TEXTURE
172 * state flag and then mark the texture object as 'incomplete' so that any
173 * per-texture derived state gets recomputed.
174 */
175 static INLINE void
176 flush(GLcontext *ctx, struct gl_texture_object *texObj)
177 {
178 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
179 texObj->_Complete = GL_FALSE;
180 }
181
182
183 /**
184 * Set an integer-valued texture parameter
185 * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
186 */
187 static GLboolean
188 set_tex_parameteri(GLcontext *ctx,
189 struct gl_texture_object *texObj,
190 GLenum pname, const GLint *params)
191 {
192 switch (pname) {
193 case GL_TEXTURE_MIN_FILTER:
194 if (texObj->MinFilter == params[0])
195 return GL_FALSE;
196 switch (params[0]) {
197 case GL_NEAREST:
198 case GL_LINEAR:
199 flush(ctx, texObj);
200 texObj->MinFilter = params[0];
201 return GL_TRUE;
202 case GL_NEAREST_MIPMAP_NEAREST:
203 case GL_LINEAR_MIPMAP_NEAREST:
204 case GL_NEAREST_MIPMAP_LINEAR:
205 case GL_LINEAR_MIPMAP_LINEAR:
206 if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
207 flush(ctx, texObj);
208 texObj->MinFilter = params[0];
209 return GL_TRUE;
210 }
211 /* fall-through */
212 default:
213 _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
214 params[0] );
215 }
216 return GL_FALSE;
217
218 case GL_TEXTURE_MAG_FILTER:
219 if (texObj->MagFilter == params[0])
220 return GL_FALSE;
221 switch (params[0]) {
222 case GL_NEAREST:
223 case GL_LINEAR:
224 flush(ctx, texObj);
225 texObj->MagFilter = params[0];
226 return GL_TRUE;
227 default:
228 _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(param=0x%x)",
229 params[0]);
230 }
231 return GL_FALSE;
232
233 case GL_TEXTURE_WRAP_S:
234 if (texObj->WrapS == params[0])
235 return GL_FALSE;
236 if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
237 flush(ctx, texObj);
238 texObj->WrapS = params[0];
239 return GL_TRUE;
240 }
241 return GL_FALSE;
242
243 case GL_TEXTURE_WRAP_T:
244 if (texObj->WrapT == params[0])
245 return GL_FALSE;
246 if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
247 flush(ctx, texObj);
248 texObj->WrapT = params[0];
249 return GL_TRUE;
250 }
251 return GL_FALSE;
252
253 case GL_TEXTURE_WRAP_R:
254 if (texObj->WrapR == params[0])
255 return GL_FALSE;
256 if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
257 flush(ctx, texObj);
258 texObj->WrapR = params[0];
259 return GL_TRUE;
260 }
261 return GL_FALSE;
262
263 case GL_TEXTURE_BASE_LEVEL:
264 if (texObj->BaseLevel == params[0])
265 return GL_FALSE;
266 if (params[0] < 0 ||
267 (texObj->Target == GL_TEXTURE_RECTANGLE_ARB && params[0] != 0)) {
268 _mesa_error(ctx, GL_INVALID_VALUE,
269 "glTexParameter(param=%d)", params[0]);
270 return GL_FALSE;
271 }
272 flush(ctx, texObj);
273 texObj->BaseLevel = params[0];
274 return GL_TRUE;
275
276 case GL_TEXTURE_MAX_LEVEL:
277 if (texObj->MaxLevel == params[0])
278 return GL_FALSE;
279 if (params[0] < 0 || texObj->Target == GL_TEXTURE_RECTANGLE_ARB) {
280 _mesa_error(ctx, GL_INVALID_OPERATION,
281 "glTexParameter(param=%d)", params[0]);
282 return GL_FALSE;
283 }
284 flush(ctx, texObj);
285 texObj->MaxLevel = params[0];
286 return GL_TRUE;
287
288 case GL_GENERATE_MIPMAP_SGIS:
289 if (ctx->Extensions.SGIS_generate_mipmap) {
290 if (texObj->GenerateMipmap != params[0]) {
291 flush(ctx, texObj);
292 texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
293 return GL_TRUE;
294 }
295 return GL_FALSE;
296 }
297 else {
298 _mesa_error(ctx, GL_INVALID_ENUM,
299 "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
300 }
301 return GL_FALSE;
302
303 case GL_TEXTURE_COMPARE_MODE_ARB:
304 if (ctx->Extensions.ARB_shadow &&
305 (params[0] == GL_NONE ||
306 params[0] == GL_COMPARE_R_TO_TEXTURE_ARB)) {
307 if (texObj->CompareMode != params[0]) {
308 flush(ctx, texObj);
309 texObj->CompareMode = params[0];
310 return GL_TRUE;
311 }
312 return GL_FALSE;
313 }
314 else {
315 _mesa_error(ctx, GL_INVALID_ENUM,
316 "glTexParameter(GL_TEXTURE_COMPARE_MODE_ARB)");
317 }
318 return GL_FALSE;
319
320 case GL_TEXTURE_COMPARE_FUNC_ARB:
321 if (ctx->Extensions.ARB_shadow) {
322 if (texObj->CompareFunc == params[0])
323 return GL_FALSE;
324 switch (params[0]) {
325 case GL_LEQUAL:
326 case GL_GEQUAL:
327 flush(ctx, texObj);
328 texObj->CompareFunc = params[0];
329 return GL_TRUE;
330 case GL_EQUAL:
331 case GL_NOTEQUAL:
332 case GL_LESS:
333 case GL_GREATER:
334 case GL_ALWAYS:
335 case GL_NEVER:
336 if (ctx->Extensions.EXT_shadow_funcs) {
337 flush(ctx, texObj);
338 texObj->CompareFunc = params[0];
339 return GL_TRUE;
340 }
341 /* fall-through */
342 default:
343 _mesa_error(ctx, GL_INVALID_ENUM,
344 "glTexParameter(GL_TEXTURE_COMPARE_FUNC_ARB)");
345 }
346 }
347 else {
348 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
349 }
350 return GL_FALSE;
351
352 case GL_DEPTH_TEXTURE_MODE_ARB:
353 if (ctx->Extensions.ARB_depth_texture &&
354 (params[0] == GL_LUMINANCE ||
355 params[0] == GL_INTENSITY ||
356 params[0] == GL_ALPHA)) {
357 if (texObj->DepthMode != params[0]) {
358 flush(ctx, texObj);
359 texObj->DepthMode = params[0];
360 return GL_TRUE;
361 }
362 }
363 else {
364 _mesa_error(ctx, GL_INVALID_ENUM,
365 "glTexParameter(GL_DEPTH_TEXTURE_MODE_ARB)");
366 }
367 return GL_FALSE;
368
369 #ifdef FEATURE_OES_draw_texture
370 case GL_TEXTURE_CROP_RECT_OES:
371 texObj->CropRect[0] = params[0];
372 texObj->CropRect[1] = params[1];
373 texObj->CropRect[2] = params[2];
374 texObj->CropRect[3] = params[3];
375 return GL_TRUE;
376 #endif
377
378 case GL_TEXTURE_SWIZZLE_R_EXT:
379 case GL_TEXTURE_SWIZZLE_G_EXT:
380 case GL_TEXTURE_SWIZZLE_B_EXT:
381 case GL_TEXTURE_SWIZZLE_A_EXT:
382 if (ctx->Extensions.EXT_texture_swizzle) {
383 const GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
384 const GLint swz = comp_to_swizzle(params[0]);
385 if (swz < 0) {
386 _mesa_error(ctx, GL_INVALID_OPERATION,
387 "glTexParameter(swizzle 0x%x)", params[0]);
388 return GL_FALSE;
389 }
390 ASSERT(comp < 4);
391 if (swz >= 0) {
392 flush(ctx, texObj);
393 texObj->Swizzle[comp] = params[0];
394 set_swizzle_component(&texObj->_Swizzle, comp, swz);
395 return GL_TRUE;
396 }
397 }
398 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
399 return GL_FALSE;
400
401 case GL_TEXTURE_SWIZZLE_RGBA_EXT:
402 if (ctx->Extensions.EXT_texture_swizzle) {
403 GLuint comp;
404 flush(ctx, texObj);
405 for (comp = 0; comp < 4; comp++) {
406 const GLint swz = comp_to_swizzle(params[comp]);
407 if (swz >= 0) {
408 texObj->Swizzle[comp] = params[comp];
409 set_swizzle_component(&texObj->_Swizzle, comp, swz);
410 }
411 else {
412 _mesa_error(ctx, GL_INVALID_OPERATION,
413 "glTexParameter(swizzle 0x%x)", params[comp]);
414 return GL_FALSE;
415 }
416 }
417 return GL_TRUE;
418 }
419 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
420 return GL_FALSE;
421
422 default:
423 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
424 }
425 return GL_FALSE;
426 }
427
428
429 /**
430 * Set a float-valued texture parameter
431 * \return GL_TRUE if legal AND the value changed, GL_FALSE otherwise
432 */
433 static GLboolean
434 set_tex_parameterf(GLcontext *ctx,
435 struct gl_texture_object *texObj,
436 GLenum pname, const GLfloat *params)
437 {
438 switch (pname) {
439 case GL_TEXTURE_MIN_LOD:
440 if (texObj->MinLod == params[0])
441 return GL_FALSE;
442 flush(ctx, texObj);
443 texObj->MinLod = params[0];
444 return GL_TRUE;
445
446 case GL_TEXTURE_MAX_LOD:
447 if (texObj->MaxLod == params[0])
448 return GL_FALSE;
449 flush(ctx, texObj);
450 texObj->MaxLod = params[0];
451 return GL_TRUE;
452
453 case GL_TEXTURE_PRIORITY:
454 flush(ctx, texObj);
455 texObj->Priority = CLAMP(params[0], 0.0F, 1.0F);
456 return GL_TRUE;
457
458 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
459 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
460 if (texObj->MaxAnisotropy == params[0])
461 return GL_FALSE;
462 if (params[0] < 1.0) {
463 _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
464 return GL_FALSE;
465 }
466 flush(ctx, texObj);
467 /* clamp to max, that's what NVIDIA does */
468 texObj->MaxAnisotropy = MIN2(params[0],
469 ctx->Const.MaxTextureMaxAnisotropy);
470 return GL_TRUE;
471 }
472 else {
473 static GLuint count = 0;
474 if (count++ < 10)
475 _mesa_error(ctx, GL_INVALID_ENUM,
476 "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
477 }
478 return GL_FALSE;
479
480 case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
481 if (ctx->Extensions.ARB_shadow_ambient) {
482 if (texObj->CompareFailValue != params[0]) {
483 flush(ctx, texObj);
484 texObj->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
485 return GL_TRUE;
486 }
487 }
488 else {
489 _mesa_error(ctx, GL_INVALID_ENUM,
490 "glTexParameter(pname=GL_TEXTURE_COMPARE_FAIL_VALUE_ARB)");
491 }
492 return GL_FALSE;
493
494 case GL_TEXTURE_LOD_BIAS:
495 /* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
496 if (ctx->Extensions.EXT_texture_lod_bias) {
497 if (texObj->LodBias != params[0]) {
498 flush(ctx, texObj);
499 texObj->LodBias = params[0];
500 return GL_TRUE;
501 }
502 return GL_FALSE;
503 }
504 break;
505
506 case GL_TEXTURE_BORDER_COLOR:
507 flush(ctx, texObj);
508 texObj->BorderColor[RCOMP] = params[0];
509 texObj->BorderColor[GCOMP] = params[1];
510 texObj->BorderColor[BCOMP] = params[2];
511 texObj->BorderColor[ACOMP] = params[3];
512 return GL_TRUE;
513
514 default:
515 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname=0x%x)", pname);
516 }
517 return GL_FALSE;
518 }
519
520
521 void GLAPIENTRY
522 _mesa_TexParameterf(GLenum target, GLenum pname, GLfloat param)
523 {
524 GLboolean need_update;
525 struct gl_texture_object *texObj;
526 GET_CURRENT_CONTEXT(ctx);
527 ASSERT_OUTSIDE_BEGIN_END(ctx);
528
529 texObj = get_texobj(ctx, target);
530 if (!texObj)
531 return;
532
533 switch (pname) {
534 case GL_TEXTURE_MIN_FILTER:
535 case GL_TEXTURE_MAG_FILTER:
536 case GL_TEXTURE_WRAP_S:
537 case GL_TEXTURE_WRAP_T:
538 case GL_TEXTURE_WRAP_R:
539 case GL_TEXTURE_BASE_LEVEL:
540 case GL_TEXTURE_MAX_LEVEL:
541 case GL_GENERATE_MIPMAP_SGIS:
542 case GL_TEXTURE_COMPARE_MODE_ARB:
543 case GL_TEXTURE_COMPARE_FUNC_ARB:
544 case GL_DEPTH_TEXTURE_MODE_ARB:
545 {
546 /* convert float param to int */
547 GLint p[4];
548 p[0] = (GLint) param;
549 p[1] = p[2] = p[3] = 0;
550 need_update = set_tex_parameteri(ctx, texObj, pname, p);
551 }
552 break;
553 default:
554 {
555 /* this will generate an error if pname is illegal */
556 GLfloat p[4];
557 p[0] = param;
558 p[1] = p[2] = p[3] = 0.0F;
559 need_update = set_tex_parameterf(ctx, texObj, pname, p);
560 }
561 }
562
563 if (ctx->Driver.TexParameter && need_update) {
564 ctx->Driver.TexParameter(ctx, target, texObj, pname, &param);
565 }
566 }
567
568
569 void GLAPIENTRY
570 _mesa_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
571 {
572 GLboolean need_update;
573 struct gl_texture_object *texObj;
574 GET_CURRENT_CONTEXT(ctx);
575 ASSERT_OUTSIDE_BEGIN_END(ctx);
576
577 texObj = get_texobj(ctx, target);
578 if (!texObj)
579 return;
580
581 switch (pname) {
582 case GL_TEXTURE_MIN_FILTER:
583 case GL_TEXTURE_MAG_FILTER:
584 case GL_TEXTURE_WRAP_S:
585 case GL_TEXTURE_WRAP_T:
586 case GL_TEXTURE_WRAP_R:
587 case GL_TEXTURE_BASE_LEVEL:
588 case GL_TEXTURE_MAX_LEVEL:
589 case GL_GENERATE_MIPMAP_SGIS:
590 case GL_TEXTURE_COMPARE_MODE_ARB:
591 case GL_TEXTURE_COMPARE_FUNC_ARB:
592 case GL_DEPTH_TEXTURE_MODE_ARB:
593 {
594 /* convert float param to int */
595 GLint p = (GLint) params[0];
596 need_update = set_tex_parameteri(ctx, texObj, pname, &p);
597 }
598 break;
599
600 #ifdef FEATURE_OES_draw_texture
601 case GL_TEXTURE_CROP_RECT_OES:
602 {
603 /* convert float params to int */
604 GLint iparams[4];
605 iparams[0] = (GLint) params[0];
606 iparams[1] = (GLint) params[1];
607 iparams[2] = (GLint) params[2];
608 iparams[3] = (GLint) params[3];
609 need_update = set_tex_parameteri(ctx, target, iparams);
610 }
611 break;
612 #endif
613
614 default:
615 /* this will generate an error if pname is illegal */
616 need_update = set_tex_parameterf(ctx, texObj, pname, params);
617 }
618
619 if (ctx->Driver.TexParameter && need_update) {
620 ctx->Driver.TexParameter(ctx, target, texObj, pname, params);
621 }
622 }
623
624
625 void GLAPIENTRY
626 _mesa_TexParameteri(GLenum target, GLenum pname, GLint param)
627 {
628 GLboolean need_update;
629 struct gl_texture_object *texObj;
630 GET_CURRENT_CONTEXT(ctx);
631 ASSERT_OUTSIDE_BEGIN_END(ctx);
632
633 texObj = get_texobj(ctx, target);
634 if (!texObj)
635 return;
636
637 switch (pname) {
638 case GL_TEXTURE_MIN_LOD:
639 case GL_TEXTURE_MAX_LOD:
640 case GL_TEXTURE_PRIORITY:
641 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
642 case GL_TEXTURE_LOD_BIAS:
643 case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
644 {
645 GLfloat fparam = (GLfloat) param;
646 /* convert int param to float */
647 need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
648 }
649 break;
650 default:
651 /* this will generate an error if pname is illegal */
652 need_update = set_tex_parameteri(ctx, texObj, pname, &param);
653 }
654
655 if (ctx->Driver.TexParameter && need_update) {
656 GLfloat fparam = (GLfloat) param;
657 ctx->Driver.TexParameter(ctx, target, texObj, pname, &fparam);
658 }
659 }
660
661
662 void GLAPIENTRY
663 _mesa_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
664 {
665 GLboolean need_update;
666 struct gl_texture_object *texObj;
667 GET_CURRENT_CONTEXT(ctx);
668 ASSERT_OUTSIDE_BEGIN_END(ctx);
669
670 texObj = get_texobj(ctx, target);
671 if (!texObj)
672 return;
673
674 switch (pname) {
675 case GL_TEXTURE_BORDER_COLOR:
676 {
677 /* convert int params to float */
678 GLfloat fparams[4];
679 fparams[0] = INT_TO_FLOAT(params[0]);
680 fparams[1] = INT_TO_FLOAT(params[1]);
681 fparams[2] = INT_TO_FLOAT(params[2]);
682 fparams[3] = INT_TO_FLOAT(params[3]);
683 need_update = set_tex_parameterf(ctx, texObj, pname, fparams);
684 }
685 break;
686 case GL_TEXTURE_MIN_LOD:
687 case GL_TEXTURE_MAX_LOD:
688 case GL_TEXTURE_PRIORITY:
689 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
690 case GL_TEXTURE_LOD_BIAS:
691 case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
692 {
693 /* convert int param to float */
694 GLfloat fparam = (GLfloat) params[0];
695 need_update = set_tex_parameterf(ctx, texObj, pname, &fparam);
696 }
697 break;
698 default:
699 /* this will generate an error if pname is illegal */
700 need_update = set_tex_parameteri(ctx, texObj, pname, params);
701 }
702
703 if (ctx->Driver.TexParameter && need_update) {
704 GLfloat fparams[4];
705 fparams[0] = INT_TO_FLOAT(params[0]);
706 if (pname == GL_TEXTURE_BORDER_COLOR ||
707 pname == GL_TEXTURE_CROP_RECT_OES) {
708 fparams[1] = INT_TO_FLOAT(params[1]);
709 fparams[2] = INT_TO_FLOAT(params[2]);
710 fparams[3] = INT_TO_FLOAT(params[3]);
711 }
712 ctx->Driver.TexParameter(ctx, target, texObj, pname, fparams);
713 }
714 }
715
716
717 void GLAPIENTRY
718 _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
719 GLenum pname, GLfloat *params )
720 {
721 GLint iparam;
722 _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
723 *params = (GLfloat) iparam;
724 }
725
726
727 void GLAPIENTRY
728 _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
729 GLenum pname, GLint *params )
730 {
731 const struct gl_texture_unit *texUnit;
732 struct gl_texture_object *texObj;
733 const struct gl_texture_image *img = NULL;
734 GLboolean isProxy;
735 GLint maxLevels;
736 GET_CURRENT_CONTEXT(ctx);
737 ASSERT_OUTSIDE_BEGIN_END(ctx);
738
739 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
740 _mesa_error(ctx, GL_INVALID_OPERATION,
741 "glGetTexLevelParameteriv(current unit)");
742 return;
743 }
744
745 texUnit = _mesa_get_current_tex_unit(ctx);
746
747 /* this will catch bad target values */
748 maxLevels = _mesa_max_texture_levels(ctx, target);
749 if (maxLevels == 0) {
750 _mesa_error(ctx, GL_INVALID_ENUM,
751 "glGetTexLevelParameter[if]v(target=0x%x)", target);
752 return;
753 }
754
755 if (level < 0 || level >= maxLevels) {
756 _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
757 return;
758 }
759
760 texObj = _mesa_select_tex_object(ctx, texUnit, target);
761 _mesa_lock_texture(ctx, texObj);
762
763 img = _mesa_select_tex_image(ctx, texObj, target, level);
764 if (!img || !img->TexFormat) {
765 /* undefined texture image */
766 if (pname == GL_TEXTURE_COMPONENTS)
767 *params = 1;
768 else
769 *params = 0;
770 goto out;
771 }
772
773 isProxy = _mesa_is_proxy_texture(target);
774
775 switch (pname) {
776 case GL_TEXTURE_WIDTH:
777 *params = img->Width;
778 break;
779 case GL_TEXTURE_HEIGHT:
780 *params = img->Height;
781 break;
782 case GL_TEXTURE_DEPTH:
783 *params = img->Depth;
784 break;
785 case GL_TEXTURE_INTERNAL_FORMAT:
786 if (img->IsCompressed) {
787 /* need to return the actual compressed format */
788 *params = _mesa_compressed_format_to_glenum(ctx,
789 img->TexFormat->MesaFormat);
790 }
791 else {
792 /* return the user's requested internal format */
793 *params = img->InternalFormat;
794 }
795 break;
796 case GL_TEXTURE_BORDER:
797 *params = img->Border;
798 break;
799 case GL_TEXTURE_RED_SIZE:
800 if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
801 *params = img->TexFormat->RedBits;
802 else
803 *params = 0;
804 break;
805 case GL_TEXTURE_GREEN_SIZE:
806 if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
807 *params = img->TexFormat->GreenBits;
808 else
809 *params = 0;
810 break;
811 case GL_TEXTURE_BLUE_SIZE:
812 if (img->_BaseFormat == GL_RGB || img->_BaseFormat == GL_RGBA)
813 *params = img->TexFormat->BlueBits;
814 else
815 *params = 0;
816 break;
817 case GL_TEXTURE_ALPHA_SIZE:
818 if (img->_BaseFormat == GL_ALPHA ||
819 img->_BaseFormat == GL_LUMINANCE_ALPHA ||
820 img->_BaseFormat == GL_RGBA)
821 *params = img->TexFormat->AlphaBits;
822 else
823 *params = 0;
824 break;
825 case GL_TEXTURE_INTENSITY_SIZE:
826 if (img->_BaseFormat != GL_INTENSITY)
827 *params = 0;
828 else if (img->TexFormat->IntensityBits > 0)
829 *params = img->TexFormat->IntensityBits;
830 else /* intensity probably stored as rgb texture */
831 *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
832 break;
833 case GL_TEXTURE_LUMINANCE_SIZE:
834 if (img->_BaseFormat != GL_LUMINANCE &&
835 img->_BaseFormat != GL_LUMINANCE_ALPHA)
836 *params = 0;
837 else if (img->TexFormat->LuminanceBits > 0)
838 *params = img->TexFormat->LuminanceBits;
839 else /* luminance probably stored as rgb texture */
840 *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
841 break;
842 case GL_TEXTURE_INDEX_SIZE_EXT:
843 if (img->_BaseFormat == GL_COLOR_INDEX)
844 *params = img->TexFormat->IndexBits;
845 else
846 *params = 0;
847 break;
848 case GL_TEXTURE_DEPTH_SIZE_ARB:
849 if (ctx->Extensions.ARB_depth_texture)
850 *params = img->TexFormat->DepthBits;
851 else
852 _mesa_error(ctx, GL_INVALID_ENUM,
853 "glGetTexLevelParameter[if]v(pname)");
854 break;
855 case GL_TEXTURE_STENCIL_SIZE_EXT:
856 if (ctx->Extensions.EXT_packed_depth_stencil ||
857 ctx->Extensions.ARB_framebuffer_object) {
858 *params = img->TexFormat->StencilBits;
859 }
860 else {
861 _mesa_error(ctx, GL_INVALID_ENUM,
862 "glGetTexLevelParameter[if]v(pname)");
863 }
864 break;
865
866 /* GL_ARB_texture_compression */
867 case GL_TEXTURE_COMPRESSED_IMAGE_SIZE:
868 if (img->IsCompressed && !isProxy) {
869 /* Don't use ctx->Driver.CompressedTextureSize() since that
870 * may returned a padded hardware size.
871 */
872 *params = _mesa_compressed_texture_size(ctx, img->Width,
873 img->Height, img->Depth,
874 img->TexFormat->MesaFormat);
875 }
876 else {
877 _mesa_error(ctx, GL_INVALID_OPERATION,
878 "glGetTexLevelParameter[if]v(pname)");
879 }
880 break;
881 case GL_TEXTURE_COMPRESSED:
882 *params = (GLint) img->IsCompressed;
883 break;
884
885 /* GL_ARB_texture_float */
886 case GL_TEXTURE_RED_TYPE_ARB:
887 if (ctx->Extensions.ARB_texture_float) {
888 *params = img->TexFormat->RedBits ? img->TexFormat->DataType : GL_NONE;
889 }
890 else {
891 _mesa_error(ctx, GL_INVALID_ENUM,
892 "glGetTexLevelParameter[if]v(pname)");
893 }
894 break;
895 case GL_TEXTURE_GREEN_TYPE_ARB:
896 if (ctx->Extensions.ARB_texture_float) {
897 *params = img->TexFormat->GreenBits ? img->TexFormat->DataType : GL_NONE;
898 }
899 else {
900 _mesa_error(ctx, GL_INVALID_ENUM,
901 "glGetTexLevelParameter[if]v(pname)");
902 }
903 break;
904 case GL_TEXTURE_BLUE_TYPE_ARB:
905 if (ctx->Extensions.ARB_texture_float) {
906 *params = img->TexFormat->BlueBits ? img->TexFormat->DataType : GL_NONE;
907 }
908 else {
909 _mesa_error(ctx, GL_INVALID_ENUM,
910 "glGetTexLevelParameter[if]v(pname)");
911 }
912 break;
913 case GL_TEXTURE_ALPHA_TYPE_ARB:
914 if (ctx->Extensions.ARB_texture_float) {
915 *params = img->TexFormat->AlphaBits ? img->TexFormat->DataType : GL_NONE;
916 }
917 else {
918 _mesa_error(ctx, GL_INVALID_ENUM,
919 "glGetTexLevelParameter[if]v(pname)");
920 }
921 break;
922 case GL_TEXTURE_LUMINANCE_TYPE_ARB:
923 if (ctx->Extensions.ARB_texture_float) {
924 *params = img->TexFormat->LuminanceBits ? img->TexFormat->DataType : GL_NONE;
925 }
926 else {
927 _mesa_error(ctx, GL_INVALID_ENUM,
928 "glGetTexLevelParameter[if]v(pname)");
929 }
930 break;
931 case GL_TEXTURE_INTENSITY_TYPE_ARB:
932 if (ctx->Extensions.ARB_texture_float) {
933 *params = img->TexFormat->IntensityBits ? img->TexFormat->DataType : GL_NONE;
934 }
935 else {
936 _mesa_error(ctx, GL_INVALID_ENUM,
937 "glGetTexLevelParameter[if]v(pname)");
938 }
939 break;
940 case GL_TEXTURE_DEPTH_TYPE_ARB:
941 if (ctx->Extensions.ARB_texture_float) {
942 *params = img->TexFormat->DepthBits ? img->TexFormat->DataType : GL_NONE;
943 }
944 else {
945 _mesa_error(ctx, GL_INVALID_ENUM,
946 "glGetTexLevelParameter[if]v(pname)");
947 }
948 break;
949
950 default:
951 _mesa_error(ctx, GL_INVALID_ENUM,
952 "glGetTexLevelParameter[if]v(pname)");
953 }
954
955 out:
956 _mesa_unlock_texture(ctx, texObj);
957 }
958
959
960
961 void GLAPIENTRY
962 _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
963 {
964 struct gl_texture_unit *texUnit;
965 struct gl_texture_object *obj;
966 GLboolean error = GL_FALSE;
967 GET_CURRENT_CONTEXT(ctx);
968 ASSERT_OUTSIDE_BEGIN_END(ctx);
969
970 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
971 _mesa_error(ctx, GL_INVALID_OPERATION,
972 "glGetTexParameterfv(current unit)");
973 return;
974 }
975
976 texUnit = _mesa_get_current_tex_unit(ctx);
977
978 obj = _mesa_select_tex_object(ctx, texUnit, target);
979 if (!obj) {
980 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
981 return;
982 }
983
984 _mesa_lock_texture(ctx, obj);
985 switch (pname) {
986 case GL_TEXTURE_MAG_FILTER:
987 *params = ENUM_TO_FLOAT(obj->MagFilter);
988 break;
989 case GL_TEXTURE_MIN_FILTER:
990 *params = ENUM_TO_FLOAT(obj->MinFilter);
991 break;
992 case GL_TEXTURE_WRAP_S:
993 *params = ENUM_TO_FLOAT(obj->WrapS);
994 break;
995 case GL_TEXTURE_WRAP_T:
996 *params = ENUM_TO_FLOAT(obj->WrapT);
997 break;
998 case GL_TEXTURE_WRAP_R:
999 *params = ENUM_TO_FLOAT(obj->WrapR);
1000 break;
1001 case GL_TEXTURE_BORDER_COLOR:
1002 params[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
1003 params[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
1004 params[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
1005 params[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
1006 break;
1007 case GL_TEXTURE_RESIDENT:
1008 {
1009 GLboolean resident;
1010 if (ctx->Driver.IsTextureResident)
1011 resident = ctx->Driver.IsTextureResident(ctx, obj);
1012 else
1013 resident = GL_TRUE;
1014 *params = ENUM_TO_FLOAT(resident);
1015 }
1016 break;
1017 case GL_TEXTURE_PRIORITY:
1018 *params = obj->Priority;
1019 break;
1020 case GL_TEXTURE_MIN_LOD:
1021 *params = obj->MinLod;
1022 break;
1023 case GL_TEXTURE_MAX_LOD:
1024 *params = obj->MaxLod;
1025 break;
1026 case GL_TEXTURE_BASE_LEVEL:
1027 *params = (GLfloat) obj->BaseLevel;
1028 break;
1029 case GL_TEXTURE_MAX_LEVEL:
1030 *params = (GLfloat) obj->MaxLevel;
1031 break;
1032 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1033 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1034 *params = obj->MaxAnisotropy;
1035 }
1036 else
1037 error = GL_TRUE;
1038 break;
1039 case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
1040 if (ctx->Extensions.ARB_shadow_ambient) {
1041 *params = obj->CompareFailValue;
1042 }
1043 else
1044 error = GL_TRUE;
1045 break;
1046 case GL_GENERATE_MIPMAP_SGIS:
1047 if (ctx->Extensions.SGIS_generate_mipmap) {
1048 *params = (GLfloat) obj->GenerateMipmap;
1049 }
1050 else
1051 error = GL_TRUE;
1052 break;
1053 case GL_TEXTURE_COMPARE_MODE_ARB:
1054 if (ctx->Extensions.ARB_shadow) {
1055 *params = (GLfloat) obj->CompareMode;
1056 }
1057 else
1058 error = GL_TRUE;
1059 break;
1060 case GL_TEXTURE_COMPARE_FUNC_ARB:
1061 if (ctx->Extensions.ARB_shadow) {
1062 *params = (GLfloat) obj->CompareFunc;
1063 }
1064 else
1065 error = GL_TRUE;
1066 break;
1067 case GL_DEPTH_TEXTURE_MODE_ARB:
1068 if (ctx->Extensions.ARB_depth_texture) {
1069 *params = (GLfloat) obj->DepthMode;
1070 }
1071 else
1072 error = GL_TRUE;
1073 break;
1074 case GL_TEXTURE_LOD_BIAS:
1075 if (ctx->Extensions.EXT_texture_lod_bias) {
1076 *params = obj->LodBias;
1077 }
1078 else
1079 error = GL_TRUE;
1080 break;
1081 #ifdef FEATURE_OES_draw_texture
1082 case GL_TEXTURE_CROP_RECT_OES:
1083 params[0] = obj->CropRect[0];
1084 params[1] = obj->CropRect[1];
1085 params[2] = obj->CropRect[2];
1086 params[3] = obj->CropRect[3];
1087 break;
1088 #endif
1089
1090 case GL_TEXTURE_SWIZZLE_R_EXT:
1091 case GL_TEXTURE_SWIZZLE_G_EXT:
1092 case GL_TEXTURE_SWIZZLE_B_EXT:
1093 case GL_TEXTURE_SWIZZLE_A_EXT:
1094 if (ctx->Extensions.EXT_texture_swizzle) {
1095 GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
1096 *params = (GLfloat) obj->Swizzle[comp];
1097 }
1098 else {
1099 error = GL_TRUE;
1100 }
1101 break;
1102
1103 case GL_TEXTURE_SWIZZLE_RGBA_EXT:
1104 if (ctx->Extensions.EXT_texture_swizzle) {
1105 GLuint comp;
1106 for (comp = 0; comp < 4; comp++) {
1107 params[comp] = (GLfloat) obj->Swizzle[comp];
1108 }
1109 }
1110 else {
1111 error = GL_TRUE;
1112 }
1113 break;
1114
1115 default:
1116 error = GL_TRUE;
1117 break;
1118 }
1119
1120 if (error)
1121 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname=0x%x)",
1122 pname);
1123
1124 _mesa_unlock_texture(ctx, obj);
1125 }
1126
1127
1128 void GLAPIENTRY
1129 _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1130 {
1131 struct gl_texture_unit *texUnit;
1132 struct gl_texture_object *obj;
1133 GLboolean error = GL_FALSE;
1134 GET_CURRENT_CONTEXT(ctx);
1135 ASSERT_OUTSIDE_BEGIN_END(ctx);
1136
1137 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
1138 _mesa_error(ctx, GL_INVALID_OPERATION,
1139 "glGetTexParameteriv(current unit)");
1140 return;
1141 }
1142
1143 texUnit = _mesa_get_current_tex_unit(ctx);
1144
1145 obj = _mesa_select_tex_object(ctx, texUnit, target);
1146 if (!obj) {
1147 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
1148 return;
1149 }
1150
1151 switch (pname) {
1152 case GL_TEXTURE_MAG_FILTER:
1153 *params = (GLint) obj->MagFilter;
1154 break;;
1155 case GL_TEXTURE_MIN_FILTER:
1156 *params = (GLint) obj->MinFilter;
1157 break;;
1158 case GL_TEXTURE_WRAP_S:
1159 *params = (GLint) obj->WrapS;
1160 break;;
1161 case GL_TEXTURE_WRAP_T:
1162 *params = (GLint) obj->WrapT;
1163 break;;
1164 case GL_TEXTURE_WRAP_R:
1165 *params = (GLint) obj->WrapR;
1166 break;;
1167 case GL_TEXTURE_BORDER_COLOR:
1168 {
1169 GLfloat b[4];
1170 b[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
1171 b[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
1172 b[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
1173 b[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
1174 params[0] = FLOAT_TO_INT(b[0]);
1175 params[1] = FLOAT_TO_INT(b[1]);
1176 params[2] = FLOAT_TO_INT(b[2]);
1177 params[3] = FLOAT_TO_INT(b[3]);
1178 }
1179 break;;
1180 case GL_TEXTURE_RESIDENT:
1181 {
1182 GLboolean resident;
1183 if (ctx->Driver.IsTextureResident)
1184 resident = ctx->Driver.IsTextureResident(ctx, obj);
1185 else
1186 resident = GL_TRUE;
1187 *params = (GLint) resident;
1188 }
1189 break;;
1190 case GL_TEXTURE_PRIORITY:
1191 *params = FLOAT_TO_INT(obj->Priority);
1192 break;;
1193 case GL_TEXTURE_MIN_LOD:
1194 *params = (GLint) obj->MinLod;
1195 break;;
1196 case GL_TEXTURE_MAX_LOD:
1197 *params = (GLint) obj->MaxLod;
1198 break;;
1199 case GL_TEXTURE_BASE_LEVEL:
1200 *params = obj->BaseLevel;
1201 break;;
1202 case GL_TEXTURE_MAX_LEVEL:
1203 *params = obj->MaxLevel;
1204 break;;
1205 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1206 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1207 *params = (GLint) obj->MaxAnisotropy;
1208 }
1209 else {
1210 error = GL_TRUE;
1211 }
1212 break;
1213 case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
1214 if (ctx->Extensions.ARB_shadow_ambient) {
1215 *params = (GLint) FLOAT_TO_INT(obj->CompareFailValue);
1216 }
1217 else {
1218 error = GL_TRUE;
1219 }
1220 break;
1221 case GL_GENERATE_MIPMAP_SGIS:
1222 if (ctx->Extensions.SGIS_generate_mipmap) {
1223 *params = (GLint) obj->GenerateMipmap;
1224 }
1225 else {
1226 error = GL_TRUE;
1227 }
1228 break;
1229 case GL_TEXTURE_COMPARE_MODE_ARB:
1230 if (ctx->Extensions.ARB_shadow) {
1231 *params = (GLint) obj->CompareMode;
1232 }
1233 else {
1234 error = GL_TRUE;
1235 }
1236 break;
1237 case GL_TEXTURE_COMPARE_FUNC_ARB:
1238 if (ctx->Extensions.ARB_shadow) {
1239 *params = (GLint) obj->CompareFunc;
1240 }
1241 else {
1242 error = GL_TRUE;
1243 }
1244 break;
1245 case GL_DEPTH_TEXTURE_MODE_ARB:
1246 if (ctx->Extensions.ARB_depth_texture) {
1247 *params = (GLint) obj->DepthMode;
1248 }
1249 else {
1250 error = GL_TRUE;
1251 }
1252 break;
1253 case GL_TEXTURE_LOD_BIAS:
1254 if (ctx->Extensions.EXT_texture_lod_bias) {
1255 *params = (GLint) obj->LodBias;
1256 }
1257 else {
1258 error = GL_TRUE;
1259 }
1260 break;
1261 #ifdef FEATURE_OES_draw_texture
1262 case GL_TEXTURE_CROP_RECT_OES:
1263 params[0] = obj->CropRect[0];
1264 params[1] = obj->CropRect[1];
1265 params[2] = obj->CropRect[2];
1266 params[3] = obj->CropRect[3];
1267 break;
1268 #endif
1269 case GL_TEXTURE_SWIZZLE_R_EXT:
1270 case GL_TEXTURE_SWIZZLE_G_EXT:
1271 case GL_TEXTURE_SWIZZLE_B_EXT:
1272 case GL_TEXTURE_SWIZZLE_A_EXT:
1273 if (ctx->Extensions.EXT_texture_swizzle) {
1274 GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
1275 *params = obj->Swizzle[comp];
1276 }
1277 else {
1278 error = GL_TRUE;
1279 }
1280 break;
1281
1282 case GL_TEXTURE_SWIZZLE_RGBA_EXT:
1283 if (ctx->Extensions.EXT_texture_swizzle) {
1284 COPY_4V(params, obj->Swizzle);
1285 }
1286 else {
1287 error = GL_TRUE;
1288 }
1289 break;
1290
1291 default:
1292 ; /* silence warnings */
1293 }
1294
1295 if (error)
1296 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)",
1297 pname);
1298
1299 _mesa_unlock_texture(ctx, obj);
1300 }