projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
initial support for GL_SGIS_generate_mipmap extension
[mesa.git] / src / mesa / main / texstate.c
1 /* $Id: texstate.c,v 1.51 2001/05/21 16:41:03 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2001 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 #ifdef PC_HEADER
29 #include "all.h"
30 #else
31 #include "glheader.h"
32 #include "colormac.h"
33 #include "context.h"
34 #include "enums.h"
35 #include "extensions.h"
36 #include "macros.h"
37 #include "texobj.h"
38 #include "teximage.h"
39 #include "texstate.h"
40 #include "mtypes.h"
41 #include "math/m_xform.h"
42 #include "math/m_matrix.h"
43 #endif
44
45
46
47 #ifdef SPECIALCAST
48 /* Needed for an Amiga compiler */
49 #define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
50 #define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
51 #else
52 /* all other compilers */
53 #define ENUM_TO_FLOAT(X) ((GLfloat)(X))
54 #define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
55 #endif
56
57
58
59 /**********************************************************************/
60 /* Texture Environment */
61 /**********************************************************************/
62
63
64 void
65 _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
66 {
67 GET_CURRENT_CONTEXT(ctx);
68 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
69 ASSERT_OUTSIDE_BEGIN_END(ctx);
70
71 #define ERROR(errCode, msg, value) \
72 { \
73 char s[100]; \
74 sprintf(s, msg, _mesa_lookup_enum_by_nr(value)); \
75 _mesa_error(ctx, errCode, s); \
76 }
77
78 if (target==GL_TEXTURE_ENV) {
79 switch (pname) {
80 case GL_TEXTURE_ENV_MODE: {
81 GLenum mode = (GLenum) (GLint) *param;
82
83 switch (mode) {
84 case GL_ADD:
85 if (!ctx->Extensions.EXT_texture_env_add) {
86 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
87 return;
88 }
89 break;
90 case GL_COMBINE_EXT:
91 if (!ctx->Extensions.EXT_texture_env_combine &&
92 !ctx->Extensions.ARB_texture_env_combine) {
93 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
94 return;
95 }
96 break;
97 case GL_MODULATE:
98 case GL_BLEND:
99 case GL_DECAL:
100 case GL_REPLACE:
101 break;
102 default:
103 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
104 return;
105 }
106
107 if (texUnit->EnvMode == mode)
108 return;
109 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
110 texUnit->EnvMode = mode;
111 break;
112 }
113 case GL_TEXTURE_ENV_COLOR: {
114 GLfloat tmp[4];
115 tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
116 tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
117 tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
118 tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
119 if (TEST_EQ_4V(tmp, texUnit->EnvColor))
120 return;
121 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
122 COPY_4FV(texUnit->EnvColor, tmp);
123 break;
124 }
125 case GL_COMBINE_RGB_EXT:
126 if (ctx->Extensions.EXT_texture_env_combine ||
127 ctx->Extensions.ARB_texture_env_combine) {
128 const GLenum mode = (GLenum) (GLint) *param;
129 switch (mode) {
130 case GL_REPLACE:
131 case GL_MODULATE:
132 case GL_ADD:
133 case GL_ADD_SIGNED_EXT:
134 case GL_INTERPOLATE_EXT:
135 /* OK */
136 break;
137 case GL_SUBTRACT_ARB:
138 if (!ctx->Extensions.ARB_texture_env_combine) {
139 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
140 return;
141 }
142 break;
143 case GL_DOT3_RGB_EXT:
144 case GL_DOT3_RGBA_EXT:
145 if (!ctx->Extensions.EXT_texture_env_dot3) {
146 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
147 return;
148 }
149 break;
150 case GL_DOT3_RGB_ARB:
151 case GL_DOT3_RGBA_ARB:
152 if (!ctx->Extensions.ARB_texture_env_dot3) {
153 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
154 return;
155 }
156 break;
157 default:
158 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
159 return;
160 }
161 if (texUnit->CombineModeRGB == mode)
162 return;
163 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
164 texUnit->CombineModeRGB = mode;
165 }
166 else {
167 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
168 return;
169 }
170 break;
171 case GL_COMBINE_ALPHA_EXT:
172 if (ctx->Extensions.EXT_texture_env_combine ||
173 ctx->Extensions.ARB_texture_env_combine) {
174 const GLenum mode = (GLenum) (GLint) *param;
175 switch (mode) {
176 case GL_REPLACE:
177 case GL_MODULATE:
178 case GL_ADD:
179 case GL_ADD_SIGNED_EXT:
180 case GL_INTERPOLATE_EXT:
181 /* OK */
182 break;
183 case GL_SUBTRACT_ARB:
184 if (!ctx->Extensions.ARB_texture_env_combine) {
185 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
186 return;
187 }
188 break;
189 default:
190 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
191 return;
192 }
193 if (texUnit->CombineModeA == mode)
194 return;
195 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
196 texUnit->CombineModeA = mode;
197 }
198 else {
199 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
200 return;
201 }
202 break;
203 case GL_SOURCE0_RGB_EXT:
204 case GL_SOURCE1_RGB_EXT:
205 case GL_SOURCE2_RGB_EXT:
206 if (ctx->Extensions.EXT_texture_env_combine ||
207 ctx->Extensions.ARB_texture_env_combine) {
208 GLenum source = (GLenum) (GLint) *param;
209 GLuint s = pname - GL_SOURCE0_RGB_EXT;
210 switch (source) {
211 case GL_TEXTURE:
212 case GL_CONSTANT_EXT:
213 case GL_PRIMARY_COLOR_EXT:
214 case GL_PREVIOUS_EXT:
215 if (texUnit->CombineSourceRGB[s] == source)
216 return;
217 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
218 texUnit->CombineSourceRGB[s] = source;
219 break;
220 default:
221 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
222 return;
223 }
224 }
225 else {
226 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
227 return;
228 }
229 break;
230 case GL_SOURCE0_ALPHA_EXT:
231 case GL_SOURCE1_ALPHA_EXT:
232 case GL_SOURCE2_ALPHA_EXT:
233 if (ctx->Extensions.EXT_texture_env_combine ||
234 ctx->Extensions.ARB_texture_env_combine) {
235 GLenum source = (GLenum) (GLint) *param;
236 GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
237 switch (source) {
238 case GL_TEXTURE:
239 case GL_CONSTANT_EXT:
240 case GL_PRIMARY_COLOR_EXT:
241 case GL_PREVIOUS_EXT:
242 if (texUnit->CombineSourceA[s] == source) return;
243 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
244 texUnit->CombineSourceA[s] = source;
245 break;
246 default:
247 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
248 return;
249 }
250 }
251 else {
252 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
253 return;
254 }
255 break;
256 case GL_OPERAND0_RGB_EXT:
257 case GL_OPERAND1_RGB_EXT:
258 if (ctx->Extensions.EXT_texture_env_combine ||
259 ctx->Extensions.ARB_texture_env_combine) {
260 GLenum operand = (GLenum) (GLint) *param;
261 GLuint s = pname - GL_OPERAND0_RGB_EXT;
262 switch (operand) {
263 case GL_SRC_COLOR:
264 case GL_ONE_MINUS_SRC_COLOR:
265 case GL_SRC_ALPHA:
266 case GL_ONE_MINUS_SRC_ALPHA:
267 if (texUnit->CombineOperandRGB[s] == operand)
268 return;
269 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
270 texUnit->CombineOperandRGB[s] = operand;
271 break;
272 default:
273 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
274 return;
275 }
276 }
277 else {
278 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
279 return;
280 }
281 break;
282 case GL_OPERAND0_ALPHA_EXT:
283 case GL_OPERAND1_ALPHA_EXT:
284 if (ctx->Extensions.EXT_texture_env_combine ||
285 ctx->Extensions.ARB_texture_env_combine) {
286 GLenum operand = (GLenum) (GLint) *param;
287 switch (operand) {
288 case GL_SRC_ALPHA:
289 case GL_ONE_MINUS_SRC_ALPHA:
290 if (texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] ==
291 operand)
292 return;
293 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
294 texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] = operand;
295 break;
296 default:
297 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
298 return;
299 }
300 }
301 else {
302 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
303 return;
304 }
305 break;
306 case GL_OPERAND2_RGB_EXT:
307 if (ctx->Extensions.EXT_texture_env_combine ||
308 ctx->Extensions.ARB_texture_env_combine) {
309 GLenum operand = (GLenum) (GLint) *param;
310 switch (operand) {
311 case GL_SRC_COLOR: /* ARB combine only */
312 case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
313 case GL_SRC_ALPHA:
314 case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
315 if (texUnit->CombineOperandRGB[2] == operand)
316 return;
317 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
318 texUnit->CombineOperandRGB[2] = operand;
319 default:
320 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
321 return;
322 }
323 }
324 else {
325 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
326 return;
327 }
328 break;
329 case GL_OPERAND2_ALPHA_EXT:
330 if (ctx->Extensions.EXT_texture_env_combine ||
331 ctx->Extensions.ARB_texture_env_combine) {
332 GLenum operand = (GLenum) (GLint) *param;
333 switch (operand) {
334 case GL_SRC_ALPHA:
335 case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
336 if (texUnit->CombineOperandA[2] == operand)
337 return;
338 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
339 texUnit->CombineOperandA[2] = operand;
340 break;
341 default:
342 ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
343 return;
344 }
345 }
346 else {
347 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
348 return;
349 }
350 break;
351 case GL_RGB_SCALE_EXT:
352 if (ctx->Extensions.EXT_texture_env_combine ||
353 ctx->Extensions.ARB_texture_env_combine) {
354 GLuint newshift;
355 if (*param == 1.0) {
356 newshift = 0;
357 }
358 else if (*param == 2.0) {
359 newshift = 1;
360 }
361 else if (*param == 4.0) {
362 newshift = 2;
363 }
364 else {
365 _mesa_error( ctx, GL_INVALID_VALUE,
366 "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
367 return;
368 }
369 if (texUnit->CombineScaleShiftRGB == newshift)
370 return;
371 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
372 texUnit->CombineScaleShiftRGB = newshift;
373 }
374 else {
375 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
376 return;
377 }
378 break;
379 case GL_ALPHA_SCALE:
380 if (ctx->Extensions.EXT_texture_env_combine ||
381 ctx->Extensions.ARB_texture_env_combine) {
382 GLuint newshift;
383 if (*param == 1.0) {
384 newshift = 0;
385 }
386 else if (*param == 2.0) {
387 newshift = 1;
388 }
389 else if (*param == 4.0) {
390 newshift = 2;
391 }
392 else {
393 _mesa_error( ctx, GL_INVALID_VALUE,
394 "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
395 return;
396 }
397 if (texUnit->CombineScaleShiftA == newshift)
398 return;
399 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
400 texUnit->CombineScaleShiftA = newshift;
401 }
402 else {
403 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
404 return;
405 }
406 break;
407 default:
408 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
409 return;
410 }
411 }
412 else if (target==GL_TEXTURE_FILTER_CONTROL_EXT) {
413 if (!ctx->Extensions.EXT_texture_lod_bias) {
414 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(param)" );
415 return;
416 }
417 switch (pname) {
418 case GL_TEXTURE_LOD_BIAS_EXT:
419 if (texUnit->LodBias == param[0])
420 return;
421 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
422 texUnit->LodBias = param[0];
423 break;
424 default:
425 ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
426 return;
427 }
428 }
429 else {
430 _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target)" );
431 return;
432 }
433
434 if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
435 fprintf(stderr, "glTexEnv %s %s %.1f(%s) ...\n",
436 _mesa_lookup_enum_by_nr(target),
437 _mesa_lookup_enum_by_nr(pname),
438 *param,
439 _mesa_lookup_enum_by_nr((GLenum) (GLint) *param));
440
441 /* Tell device driver about the new texture environment */
442 if (ctx->Driver.TexEnv) {
443 (*ctx->Driver.TexEnv)( ctx, target, pname, param );
444 }
445 }
446
447
448 void
449 _mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
450 {
451 _mesa_TexEnvfv( target, pname, &param );
452 }
453
454
455
456 void
457 _mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
458 {
459 GLfloat p[4];
460 p[0] = (GLfloat) param;
461 p[1] = p[2] = p[3] = 0.0;
462 _mesa_TexEnvfv( target, pname, p );
463 }
464
465
466 void
467 _mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
468 {
469 GLfloat p[4];
470 p[0] = INT_TO_FLOAT( param[0] );
471 p[1] = INT_TO_FLOAT( param[1] );
472 p[2] = INT_TO_FLOAT( param[2] );
473 p[3] = INT_TO_FLOAT( param[3] );
474 _mesa_TexEnvfv( target, pname, p );
475 }
476
477
478 void
479 _mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
480 {
481 GET_CURRENT_CONTEXT(ctx);
482 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
483 ASSERT_OUTSIDE_BEGIN_END(ctx);
484
485 if (target!=GL_TEXTURE_ENV) {
486 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
487 return;
488 }
489
490 switch (pname) {
491 case GL_TEXTURE_ENV_MODE:
492 *params = ENUM_TO_FLOAT(texUnit->EnvMode);
493 break;
494 case GL_TEXTURE_ENV_COLOR:
495 COPY_4FV( params, texUnit->EnvColor );
496 break;
497 case GL_COMBINE_RGB_EXT:
498 if (ctx->Extensions.EXT_texture_env_combine ||
499 ctx->Extensions.ARB_texture_env_combine) {
500 *params = (GLfloat) texUnit->CombineModeRGB;
501 }
502 else {
503 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
504 }
505 break;
506 case GL_COMBINE_ALPHA_EXT:
507 if (ctx->Extensions.EXT_texture_env_combine ||
508 ctx->Extensions.ARB_texture_env_combine) {
509 *params = (GLfloat) texUnit->CombineModeA;
510 }
511 else {
512 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
513 }
514 break;
515 case GL_SOURCE0_RGB_EXT:
516 if (ctx->Extensions.EXT_texture_env_combine ||
517 ctx->Extensions.ARB_texture_env_combine) {
518 *params = (GLfloat) texUnit->CombineSourceRGB[0];
519 }
520 else {
521 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
522 }
523 break;
524 case GL_SOURCE1_RGB_EXT:
525 if (ctx->Extensions.EXT_texture_env_combine ||
526 ctx->Extensions.ARB_texture_env_combine) {
527 *params = (GLfloat) texUnit->CombineSourceRGB[1];
528 }
529 else {
530 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
531 }
532 break;
533 case GL_SOURCE2_RGB_EXT:
534 if (ctx->Extensions.EXT_texture_env_combine ||
535 ctx->Extensions.ARB_texture_env_combine) {
536 *params = (GLfloat) texUnit->CombineSourceRGB[2];
537 }
538 else {
539 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
540 }
541 break;
542 case GL_SOURCE0_ALPHA_EXT:
543 if (ctx->Extensions.EXT_texture_env_combine ||
544 ctx->Extensions.ARB_texture_env_combine) {
545 *params = (GLfloat) texUnit->CombineSourceA[0];
546 }
547 else {
548 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
549 }
550 break;
551 case GL_SOURCE1_ALPHA_EXT:
552 if (ctx->Extensions.EXT_texture_env_combine ||
553 ctx->Extensions.ARB_texture_env_combine) {
554 *params = (GLfloat) texUnit->CombineSourceA[1];
555 }
556 else {
557 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
558 }
559 break;
560 case GL_SOURCE2_ALPHA_EXT:
561 if (ctx->Extensions.EXT_texture_env_combine ||
562 ctx->Extensions.ARB_texture_env_combine) {
563 *params = (GLfloat) texUnit->CombineSourceA[2];
564 }
565 else {
566 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
567 }
568 break;
569 case GL_OPERAND0_RGB_EXT:
570 if (ctx->Extensions.EXT_texture_env_combine ||
571 ctx->Extensions.ARB_texture_env_combine) {
572 *params = (GLfloat) texUnit->CombineOperandRGB[0];
573 }
574 else {
575 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
576 }
577 break;
578 case GL_OPERAND1_RGB_EXT:
579 if (ctx->Extensions.EXT_texture_env_combine ||
580 ctx->Extensions.ARB_texture_env_combine) {
581 *params = (GLfloat) texUnit->CombineOperandRGB[1];
582 }
583 else {
584 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
585 }
586 break;
587 case GL_OPERAND2_RGB_EXT:
588 if (ctx->Extensions.EXT_texture_env_combine ||
589 ctx->Extensions.ARB_texture_env_combine) {
590 *params = (GLfloat) texUnit->CombineOperandRGB[2];
591 }
592 else {
593 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
594 }
595 break;
596 case GL_OPERAND0_ALPHA_EXT:
597 if (ctx->Extensions.EXT_texture_env_combine ||
598 ctx->Extensions.ARB_texture_env_combine) {
599 *params = (GLfloat) texUnit->CombineOperandA[0];
600 }
601 else {
602 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
603 }
604 break;
605 case GL_OPERAND1_ALPHA_EXT:
606 if (ctx->Extensions.EXT_texture_env_combine ||
607 ctx->Extensions.ARB_texture_env_combine) {
608 *params = (GLfloat) texUnit->CombineOperandA[1];
609 }
610 else {
611 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
612 }
613 break;
614 case GL_OPERAND2_ALPHA_EXT:
615 if (ctx->Extensions.EXT_texture_env_combine ||
616 ctx->Extensions.ARB_texture_env_combine) {
617 *params = (GLfloat) texUnit->CombineOperandA[2];
618 }
619 else {
620 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
621 }
622 break;
623 case GL_RGB_SCALE_EXT:
624 if (ctx->Extensions.EXT_texture_env_combine ||
625 ctx->Extensions.ARB_texture_env_combine) {
626 if (texUnit->CombineScaleShiftRGB == 0)
627 *params = 1.0;
628 else if (texUnit->CombineScaleShiftRGB == 1)
629 *params = 2.0;
630 else
631 *params = 4.0;
632 }
633 else {
634 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
635 return;
636 }
637 break;
638 case GL_ALPHA_SCALE:
639 if (ctx->Extensions.EXT_texture_env_combine ||
640 ctx->Extensions.ARB_texture_env_combine) {
641 if (texUnit->CombineScaleShiftA == 0)
642 *params = 1.0;
643 else if (texUnit->CombineScaleShiftA == 1)
644 *params = 2.0;
645 else
646 *params = 4.0;
647 }
648 else {
649 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
650 return;
651 }
652 break;
653 default:
654 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
655 }
656 }
657
658
659 void
660 _mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
661 {
662 GET_CURRENT_CONTEXT(ctx);
663 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
664 ASSERT_OUTSIDE_BEGIN_END(ctx);
665
666 if (target != GL_TEXTURE_ENV) {
667 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
668 return;
669 }
670
671 switch (pname) {
672 case GL_TEXTURE_ENV_MODE:
673 *params = (GLint) texUnit->EnvMode;
674 break;
675 case GL_TEXTURE_ENV_COLOR:
676 params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
677 params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
678 params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
679 params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
680 break;
681 case GL_COMBINE_RGB_EXT:
682 if (ctx->Extensions.EXT_texture_env_combine ||
683 ctx->Extensions.ARB_texture_env_combine) {
684 *params = (GLint) texUnit->CombineModeRGB;
685 }
686 else {
687 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
688 }
689 break;
690 case GL_COMBINE_ALPHA_EXT:
691 if (ctx->Extensions.EXT_texture_env_combine ||
692 ctx->Extensions.ARB_texture_env_combine) {
693 *params = (GLint) texUnit->CombineModeA;
694 }
695 else {
696 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
697 }
698 break;
699 case GL_SOURCE0_RGB_EXT:
700 if (ctx->Extensions.EXT_texture_env_combine ||
701 ctx->Extensions.ARB_texture_env_combine) {
702 *params = (GLint) texUnit->CombineSourceRGB[0];
703 }
704 else {
705 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
706 }
707 break;
708 case GL_SOURCE1_RGB_EXT:
709 if (ctx->Extensions.EXT_texture_env_combine ||
710 ctx->Extensions.ARB_texture_env_combine) {
711 *params = (GLint) texUnit->CombineSourceRGB[1];
712 }
713 else {
714 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
715 }
716 break;
717 case GL_SOURCE2_RGB_EXT:
718 if (ctx->Extensions.EXT_texture_env_combine ||
719 ctx->Extensions.ARB_texture_env_combine) {
720 *params = (GLint) texUnit->CombineSourceRGB[2];
721 }
722 else {
723 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
724 }
725 break;
726 case GL_SOURCE0_ALPHA_EXT:
727 if (ctx->Extensions.EXT_texture_env_combine ||
728 ctx->Extensions.ARB_texture_env_combine) {
729 *params = (GLint) texUnit->CombineSourceA[0];
730 }
731 else {
732 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
733 }
734 break;
735 case GL_SOURCE1_ALPHA_EXT:
736 if (ctx->Extensions.EXT_texture_env_combine ||
737 ctx->Extensions.ARB_texture_env_combine) {
738 *params = (GLint) texUnit->CombineSourceA[1];
739 }
740 else {
741 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
742 }
743 break;
744 case GL_SOURCE2_ALPHA_EXT:
745 if (ctx->Extensions.EXT_texture_env_combine ||
746 ctx->Extensions.ARB_texture_env_combine) {
747 *params = (GLint) texUnit->CombineSourceA[2];
748 }
749 else {
750 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
751 }
752 break;
753 case GL_OPERAND0_RGB_EXT:
754 if (ctx->Extensions.EXT_texture_env_combine ||
755 ctx->Extensions.ARB_texture_env_combine) {
756 *params = (GLint) texUnit->CombineOperandRGB[0];
757 }
758 else {
759 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
760 }
761 break;
762 case GL_OPERAND1_RGB_EXT:
763 if (ctx->Extensions.EXT_texture_env_combine ||
764 ctx->Extensions.ARB_texture_env_combine) {
765 *params = (GLint) texUnit->CombineOperandRGB[1];
766 }
767 else {
768 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
769 }
770 break;
771 case GL_OPERAND2_RGB_EXT:
772 if (ctx->Extensions.EXT_texture_env_combine ||
773 ctx->Extensions.ARB_texture_env_combine) {
774 *params = (GLint) texUnit->CombineOperandRGB[2];
775 }
776 else {
777 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
778 }
779 break;
780 case GL_OPERAND0_ALPHA_EXT:
781 if (ctx->Extensions.EXT_texture_env_combine ||
782 ctx->Extensions.ARB_texture_env_combine) {
783 *params = (GLint) texUnit->CombineOperandA[0];
784 }
785 else {
786 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
787 }
788 break;
789 case GL_OPERAND1_ALPHA_EXT:
790 if (ctx->Extensions.EXT_texture_env_combine ||
791 ctx->Extensions.ARB_texture_env_combine) {
792 *params = (GLint) texUnit->CombineOperandA[1];
793 }
794 else {
795 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
796 }
797 break;
798 case GL_OPERAND2_ALPHA_EXT:
799 if (ctx->Extensions.EXT_texture_env_combine ||
800 ctx->Extensions.ARB_texture_env_combine) {
801 *params = (GLint) texUnit->CombineOperandA[2];
802 }
803 else {
804 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
805 }
806 break;
807 case GL_RGB_SCALE_EXT:
808 if (ctx->Extensions.EXT_texture_env_combine ||
809 ctx->Extensions.ARB_texture_env_combine) {
810 if (texUnit->CombineScaleShiftRGB == 0)
811 *params = 1;
812 else if (texUnit->CombineScaleShiftRGB == 1)
813 *params = 2;
814 else
815 *params = 4;
816 }
817 else {
818 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
819 return;
820 }
821 break;
822 case GL_ALPHA_SCALE:
823 if (ctx->Extensions.EXT_texture_env_combine ||
824 ctx->Extensions.ARB_texture_env_combine) {
825 if (texUnit->CombineScaleShiftA == 0)
826 *params = 1;
827 else if (texUnit->CombineScaleShiftA == 1)
828 *params = 2;
829 else
830 *params = 4;
831 }
832 else {
833 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
834 return;
835 }
836 break;
837 default:
838 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
839 }
840 }
841
842
843
844
845 /**********************************************************************/
846 /* Texture Parameters */
847 /**********************************************************************/
848
849
850 void
851 _mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
852 {
853 _mesa_TexParameterfv(target, pname, &param);
854 }
855
856
857 void
858 _mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
859 {
860 GET_CURRENT_CONTEXT(ctx);
861 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
862 GLenum eparam = (GLenum) (GLint) params[0];
863 struct gl_texture_object *texObj;
864 ASSERT_OUTSIDE_BEGIN_END(ctx);
865
866 if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
867 fprintf(stderr, "texPARAM %s %s %d...\n",
868 _mesa_lookup_enum_by_nr(target),
869 _mesa_lookup_enum_by_nr(pname),
870 eparam);
871
872
873 switch (target) {
874 case GL_TEXTURE_1D:
875 texObj = texUnit->Current1D;
876 break;
877 case GL_TEXTURE_2D:
878 texObj = texUnit->Current2D;
879 break;
880 case GL_TEXTURE_3D_EXT:
881 texObj = texUnit->Current3D;
882 break;
883 case GL_TEXTURE_CUBE_MAP_ARB:
884 if (ctx->Extensions.ARB_texture_cube_map) {
885 texObj = texUnit->CurrentCubeMap;
886 break;
887 }
888 /* fallthrough */
889 default:
890 _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
891 return;
892 }
893
894 switch (pname) {
895 case GL_TEXTURE_MIN_FILTER:
896 /* A small optimization */
897 if (texObj->MinFilter == eparam)
898 return;
899
900 if (eparam==GL_NEAREST || eparam==GL_LINEAR
901 || eparam==GL_NEAREST_MIPMAP_NEAREST
902 || eparam==GL_LINEAR_MIPMAP_NEAREST
903 || eparam==GL_NEAREST_MIPMAP_LINEAR
904 || eparam==GL_LINEAR_MIPMAP_LINEAR) {
905 texObj->MinFilter = eparam;
906 }
907 else {
908 _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
909 return;
910 }
911 break;
912 case GL_TEXTURE_MAG_FILTER:
913 /* A small optimization */
914 if (texObj->MagFilter == eparam)
915 return;
916
917 if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
918 texObj->MagFilter = eparam;
919 }
920 else {
921 _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
922 return;
923 }
924 break;
925 case GL_TEXTURE_WRAP_S:
926 if (texObj->WrapS == eparam)
927 return;
928 if (eparam==GL_CLAMP ||
929 eparam==GL_REPEAT ||
930 eparam==GL_CLAMP_TO_EDGE ||
931 (eparam == GL_CLAMP_TO_BORDER_ARB &&
932 ctx->Extensions.ARB_texture_border_clamp)) {
933 texObj->WrapS = eparam;
934 }
935 else {
936 _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
937 return;
938 }
939 break;
940 case GL_TEXTURE_WRAP_T:
941 if (texObj->WrapT == eparam)
942 return;
943 if (eparam==GL_CLAMP ||
944 eparam==GL_REPEAT ||
945 eparam==GL_CLAMP_TO_EDGE ||
946 (eparam == GL_CLAMP_TO_BORDER_ARB &&
947 ctx->Extensions.ARB_texture_border_clamp)) {
948 texObj->WrapT = eparam;
949 }
950 else {
951 _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
952 return;
953 }
954 break;
955 case GL_TEXTURE_WRAP_R_EXT:
956 if (texObj->WrapR == eparam)
957 return;
958 if (eparam==GL_CLAMP ||
959 eparam==GL_REPEAT ||
960 eparam==GL_CLAMP_TO_EDGE ||
961 (eparam == GL_CLAMP_TO_BORDER_ARB &&
962 ctx->Extensions.ARB_texture_border_clamp)) {
963 texObj->WrapR = eparam;
964 }
965 else {
966 _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
967 }
968 break;
969 case GL_TEXTURE_BORDER_COLOR:
970 UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[0], params[0]);
971 UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[1], params[1]);
972 UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[2], params[2]);
973 UNCLAMPED_FLOAT_TO_CHAN(texObj->BorderColor[3], params[3]);
974 break;
975 case GL_TEXTURE_MIN_LOD:
976 texObj->MinLod = params[0];
977 break;
978 case GL_TEXTURE_MAX_LOD:
979 texObj->MaxLod = params[0];
980 break;
981 case GL_TEXTURE_BASE_LEVEL:
982 if (params[0] < 0.0) {
983 _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
984 return;
985 }
986 texObj->BaseLevel = (GLint) params[0];
987 break;
988 case GL_TEXTURE_MAX_LEVEL:
989 if (params[0] < 0.0) {
990 _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
991 return;
992 }
993 texObj->MaxLevel = (GLint) params[0];
994 break;
995 case GL_TEXTURE_PRIORITY:
996 /* (keithh@netcomuk.co.uk) */
997 texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
998 break;
999 case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1000 if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1001 if (params[0] < 1.0) {
1002 _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1003 return;
1004 }
1005 texObj->MaxAnisotropy = params[0];
1006 }
1007 else {
1008 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1009 return;
1010 }
1011 break;
1012 case GL_TEXTURE_COMPARE_SGIX:
1013 if (ctx->Extensions.SGIX_shadow) {
1014 texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
1015 }
1016 else {
1017 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1018 return;
1019 }
1020 break;
1021 case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1022 if (ctx->Extensions.SGIX_shadow) {
1023 GLenum op = (GLenum) params[0];
1024 if (op == GL_TEXTURE_LEQUAL_R_SGIX ||
1025 op == GL_TEXTURE_GEQUAL_R_SGIX) {
1026 texObj->CompareOperator = op;
1027 }
1028 else {
1029 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
1030 }
1031 }
1032 else {
1033 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1034 return;
1035 }
1036 break;
1037 case GL_SHADOW_AMBIENT_SGIX:
1038 if (ctx->Extensions.SGIX_shadow_ambient) {
1039 UNCLAMPED_FLOAT_TO_CHAN(texObj->ShadowAmbient, params[0]);
1040 }
1041 else {
1042 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1043 return;
1044 }
1045 break;
1046 case GL_GENERATE_MIPMAP_SGIS:
1047 if (ctx->Extensions.SGIS_generate_mipmap) {
1048 texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
1049 }
1050 else {
1051 _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(pname)");
1052 return;
1053 }
1054 break;
1055 default:
1056 _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(pname)" );
1057 return;
1058 }
1059
1060 ctx->NewState |= _NEW_TEXTURE;
1061 texObj->Complete = GL_FALSE;
1062
1063 if (ctx->Driver.TexParameter) {
1064 (*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
1065 }
1066 }
1067
1068
1069 void
1070 _mesa_TexParameteri( GLenum target, GLenum pname, GLint param )
1071 {
1072 GLfloat fparam[4];
1073 fparam[0] = (GLfloat) param;
1074 fparam[1] = fparam[2] = fparam[3] = 0.0;
1075 _mesa_TexParameterfv(target, pname, fparam);
1076 }
1077
1078 void
1079 _mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
1080 {
1081 GLfloat fparam[4];
1082 fparam[0] = (GLfloat) params[0];
1083 fparam[1] = fparam[2] = fparam[3] = 0.0;
1084 _mesa_TexParameterfv(target, pname, fparam);
1085 }
1086
1087
1088 void
1089 _mesa_GetTexLevelParameterfv( GLenum target, GLint level,
1090 GLenum pname, GLfloat *params )
1091 {
1092 GLint iparam;
1093 _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
1094 *params = (GLfloat) iparam;
1095 }
1096
1097
1098 static GLuint
1099 tex_image_dimensions(GLcontext *ctx, GLenum target)
1100 {
1101 switch (target) {
1102 case GL_TEXTURE_1D:
1103 case GL_PROXY_TEXTURE_1D:
1104 return 1;
1105 case GL_TEXTURE_2D:
1106 case GL_PROXY_TEXTURE_2D:
1107 return 2;
1108 case GL_TEXTURE_3D:
1109 case GL_PROXY_TEXTURE_3D:
1110 return 3;
1111 case GL_TEXTURE_CUBE_MAP_ARB:
1112 case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
1113 case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
1114 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
1115 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
1116 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
1117 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
1118 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
1119 return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
1120 default:
1121 _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
1122 return 0;
1123 }
1124 }
1125
1126
1127 void
1128 _mesa_GetTexLevelParameteriv( GLenum target, GLint level,
1129 GLenum pname, GLint *params )
1130 {
1131 GET_CURRENT_CONTEXT(ctx);
1132 const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1133 const struct gl_texture_image *img = NULL;
1134 GLuint dimensions;
1135 GLboolean isProxy;
1136 ASSERT_OUTSIDE_BEGIN_END(ctx);
1137
1138 if (level < 0 || level >= ctx->Const.MaxTextureLevels) {
1139 _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
1140 return;
1141 }
1142
1143 dimensions = tex_image_dimensions(ctx, target); /* 1, 2 or 3 */
1144 if (dimensions == 0) {
1145 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
1146 return;
1147 }
1148
1149 img = _mesa_select_tex_image(ctx, texUnit, target, level);
1150 if (!img || !img->TexFormat) {
1151 /* undefined texture image */
1152 if (pname == GL_TEXTURE_COMPONENTS)
1153 *params = 1;
1154 else
1155 *params = 0;
1156 return;
1157 }
1158
1159 isProxy = (target == GL_PROXY_TEXTURE_1D) ||
1160 (target == GL_PROXY_TEXTURE_2D) ||
1161 (target == GL_PROXY_TEXTURE_3D) ||
1162 (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB);
1163
1164 switch (pname) {
1165 case GL_TEXTURE_WIDTH:
1166 *params = img->Width;
1167 return;
1168 case GL_TEXTURE_HEIGHT:
1169 *params = img->Height;
1170 return;
1171 case GL_TEXTURE_DEPTH:
1172 *params = img->Depth;
1173 return;
1174 case GL_TEXTURE_INTERNAL_FORMAT:
1175 *params = img->IntFormat;
1176 return;
1177 case GL_TEXTURE_BORDER:
1178 *params = img->Border;
1179 return;
1180 case GL_TEXTURE_RED_SIZE:
1181 if (img->Format == GL_RGB || img->Format == GL_RGBA)
1182 *params = img->TexFormat->RedBits;
1183 else
1184 *params = 0;
1185 return;
1186 case GL_TEXTURE_GREEN_SIZE:
1187 if (img->Format == GL_RGB || img->Format == GL_RGBA)
1188 *params = img->TexFormat->GreenBits;
1189 else
1190 *params = 0;
1191 return;
1192 case GL_TEXTURE_BLUE_SIZE:
1193 if (img->Format == GL_RGB || img->Format == GL_RGBA)
1194 *params = img->TexFormat->BlueBits;
1195 else
1196 *params = 0;
1197 return;
1198 case GL_TEXTURE_ALPHA_SIZE:
1199 if (img->Format == GL_ALPHA || img->Format == GL_LUMINANCE_ALPHA ||
1200 img->Format == GL_RGBA)
1201 *params = img->TexFormat->AlphaBits;
1202 else
1203 *params = 0;
1204 return;
1205 case GL_TEXTURE_INTENSITY_SIZE:
1206 if (img->Format != GL_INTENSITY)
1207 *params = 0;
1208 else if (img->TexFormat->IntensityBits > 0)
1209 *params = img->TexFormat->IntensityBits;
1210 else /* intensity probably stored as rgb texture */
1211 *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1212 return;
1213 case GL_TEXTURE_LUMINANCE_SIZE:
1214 if (img->Format != GL_LUMINANCE &&
1215 img->Format != GL_LUMINANCE_ALPHA)
1216 *params = 0;
1217 else if (img->TexFormat->LuminanceBits > 0)
1218 *params = img->TexFormat->LuminanceBits;
1219 else /* luminance probably stored as rgb texture */
1220 *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1221 return;
1222 case GL_TEXTURE_INDEX_SIZE_EXT:
1223 if (img->Format == GL_COLOR_INDEX)
1224 *params = img->TexFormat->IndexBits;
1225 else
1226 *params = 0;
1227 return;
1228 case GL_DEPTH_BITS:
1229 /* XXX this isn't in the GL_SGIX_depth_texture spec
1230 * but seems appropriate.
1231 */
1232 if (ctx->Extensions.SGIX_depth_texture)
1233 *params = img->TexFormat->DepthBits;
1234 else
1235 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1236 return;
1237
1238 /* GL_ARB_texture_compression */
1239 case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:
1240 if (ctx->Extensions.ARB_texture_compression) {
1241 if (img->IsCompressed && !isProxy)
1242 *params = img->CompressedSize;
1243 else
1244 _mesa_error(ctx, GL_INVALID_OPERATION,
1245 "glGetTexLevelParameter[if]v(pname)");
1246 }
1247 else {
1248 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1249 }
1250 return;
1251 case GL_TEXTURE_COMPRESSED_ARB:
1252 if (ctx->Extensions.ARB_texture_compression) {
1253 *params = (GLint) img->IsCompressed;
1254 }
1255 else {
1256 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1257 }
1258 return;
1259
1260 default:
1261 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(pname)");
1262 }
1263 }
1264
1265
1266
1267 void
1268 _mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
1269 {
1270 GET_CURRENT_CONTEXT(ctx);
1271 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1272 struct gl_texture_object *obj;
1273 ASSERT_OUTSIDE_BEGIN_END(ctx);
1274
1275 obj = _mesa_select_tex_object(ctx, texUnit, target);
1276 if (!obj) {
1277 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
1278 return;
1279 }
1280
1281 switch (pname) {
1282 case GL_TEXTURE_MAG_FILTER:
1283 *params = ENUM_TO_FLOAT(obj->MagFilter);
1284 return;
1285 case GL_TEXTURE_MIN_FILTER:
1286 *params = ENUM_TO_FLOAT(obj->MinFilter);
1287 return;
1288 case GL_TEXTURE_WRAP_S:
1289 *params = ENUM_TO_FLOAT(obj->WrapS);
1290 return;
1291 case GL_TEXTURE_WRAP_T:
1292 *params = ENUM_TO_FLOAT(obj->WrapT);
1293 return;
1294 case GL_TEXTURE_WRAP_R_EXT:
1295 *params = ENUM_TO_FLOAT(obj->WrapR);
1296 return;
1297 case GL_TEXTURE_BORDER_COLOR:
1298 params[0] = obj->BorderColor[0] / CHAN_MAXF;
1299 params[1] = obj->BorderColor[1] / CHAN_MAXF;
1300 params[2] = obj->BorderColor[2] / CHAN_MAXF;
1301 params[3] = obj->BorderColor[3] / CHAN_MAXF;
1302 return;
1303 case GL_TEXTURE_RESIDENT:
1304 {
1305 GLboolean resident;
1306 if (ctx->Driver.IsTextureResident)
1307 resident = ctx->Driver.IsTextureResident(ctx, obj);
1308 else
1309 resident = GL_TRUE;
1310 *params = ENUM_TO_FLOAT(resident);
1311 }
1312 return;
1313 case GL_TEXTURE_PRIORITY:
1314 *params = obj->Priority;
1315 return;
1316 case GL_TEXTURE_MIN_LOD:
1317 *params = obj->MinLod;
1318 return;
1319 case GL_TEXTURE_MAX_LOD:
1320 *params = obj->MaxLod;
1321 return;
1322 case GL_TEXTURE_BASE_LEVEL:
1323 *params = (GLfloat) obj->BaseLevel;
1324 return;
1325 case GL_TEXTURE_MAX_LEVEL:
1326 *params = (GLfloat) obj->MaxLevel;
1327 return;
1328 case GL_TEXTURE_COMPARE_SGIX:
1329 if (ctx->Extensions.SGIX_shadow) {
1330 *params = (GLfloat) obj->CompareFlag;
1331 return;
1332 }
1333 break;
1334 case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1335 if (ctx->Extensions.SGIX_shadow) {
1336 *params = (GLfloat) obj->CompareOperator;
1337 return;
1338 }
1339 break;
1340 case GL_SHADOW_AMBIENT_SGIX:
1341 if (ctx->Extensions.SGIX_shadow_ambient) {
1342 *params = CHAN_TO_FLOAT(obj->ShadowAmbient);
1343 return;
1344 }
1345 break;
1346 case GL_GENERATE_MIPMAP_SGIS:
1347 if (ctx->Extensions.SGIS_generate_mipmap) {
1348 *params = (GLfloat) obj->GenerateMipmap;
1349 return;
1350 }
1351 break;
1352 default:
1353 ; /* silence warnings */
1354 }
1355 /* If we get here, pname was an unrecognized enum */
1356 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
1357 }
1358
1359
1360 void
1361 _mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1362 {
1363 GET_CURRENT_CONTEXT(ctx);
1364 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1365 struct gl_texture_object *obj;
1366 ASSERT_OUTSIDE_BEGIN_END(ctx);
1367
1368 obj = _mesa_select_tex_object(ctx, texUnit, target);
1369 if (!obj) {
1370 _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
1371 return;
1372 }
1373
1374 switch (pname) {
1375 case GL_TEXTURE_MAG_FILTER:
1376 *params = (GLint) obj->MagFilter;
1377 return;
1378 case GL_TEXTURE_MIN_FILTER:
1379 *params = (GLint) obj->MinFilter;
1380 return;
1381 case GL_TEXTURE_WRAP_S:
1382 *params = (GLint) obj->WrapS;
1383 return;
1384 case GL_TEXTURE_WRAP_T:
1385 *params = (GLint) obj->WrapT;
1386 return;
1387 case GL_TEXTURE_WRAP_R_EXT:
1388 *params = (GLint) obj->WrapR;
1389 return;
1390 case GL_TEXTURE_BORDER_COLOR:
1391 {
1392 GLfloat color[4];
1393 color[0] = obj->BorderColor[0] / CHAN_MAXF;
1394 color[1] = obj->BorderColor[1] / CHAN_MAXF;
1395 color[2] = obj->BorderColor[2] / CHAN_MAXF;
1396 color[3] = obj->BorderColor[3] / CHAN_MAXF;
1397 params[0] = FLOAT_TO_INT( color[0] );
1398 params[1] = FLOAT_TO_INT( color[1] );
1399 params[2] = FLOAT_TO_INT( color[2] );
1400 params[3] = FLOAT_TO_INT( color[3] );
1401 }
1402 return;
1403 case GL_TEXTURE_RESIDENT:
1404 {
1405 GLboolean resident;
1406 if (ctx->Driver.IsTextureResident)
1407 resident = ctx->Driver.IsTextureResident(ctx, obj);
1408 else
1409 resident = GL_TRUE;
1410 *params = (GLint) resident;
1411 }
1412 return;
1413 case GL_TEXTURE_PRIORITY:
1414 *params = (GLint) obj->Priority;
1415 return;
1416 case GL_TEXTURE_MIN_LOD:
1417 *params = (GLint) obj->MinLod;
1418 return;
1419 case GL_TEXTURE_MAX_LOD:
1420 *params = (GLint) obj->MaxLod;
1421 return;
1422 case GL_TEXTURE_BASE_LEVEL:
1423 *params = obj->BaseLevel;
1424 return;
1425 case GL_TEXTURE_MAX_LEVEL:
1426 *params = obj->MaxLevel;
1427 return;
1428 case GL_TEXTURE_COMPARE_SGIX:
1429 if (ctx->Extensions.SGIX_shadow) {
1430 *params = (GLint) obj->CompareFlag;
1431 return;
1432 }
1433 break;
1434 case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1435 if (ctx->Extensions.SGIX_shadow) {
1436 *params = (GLint) obj->CompareOperator;
1437 return;
1438 }
1439 break;
1440 case GL_SHADOW_AMBIENT_SGIX:
1441 if (ctx->Extensions.SGIX_shadow_ambient) {
1442 /* XXX range? */
1443 *params = (GLint) CHAN_TO_FLOAT(obj->ShadowAmbient);
1444 return;
1445 }
1446 break;
1447 case GL_GENERATE_MIPMAP_SGIS:
1448 if (ctx->Extensions.SGIS_generate_mipmap) {
1449 *params = (GLint) obj->GenerateMipmap;
1450 return;
1451 }
1452 break;
1453 default:
1454 ; /* silence warnings */
1455 }
1456 /* If we get here, pname was an unrecognized enum */
1457 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
1458 }
1459
1460
1461
1462
1463 /**********************************************************************/
1464 /* Texture Coord Generation */
1465 /**********************************************************************/
1466
1467
1468 void
1469 _mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1470 {
1471 GET_CURRENT_CONTEXT(ctx);
1472 GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1473 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1474 ASSERT_OUTSIDE_BEGIN_END(ctx);
1475
1476 if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
1477 fprintf(stderr, "texGEN %s %s %x...\n",
1478 _mesa_lookup_enum_by_nr(coord),
1479 _mesa_lookup_enum_by_nr(pname),
1480 *(int *)params);
1481
1482 switch (coord) {
1483 case GL_S:
1484 if (pname==GL_TEXTURE_GEN_MODE) {
1485 GLenum mode = (GLenum) (GLint) *params;
1486 GLuint bits;
1487 switch (mode) {
1488 case GL_OBJECT_LINEAR:
1489 bits = TEXGEN_OBJ_LINEAR;
1490 break;
1491 case GL_EYE_LINEAR:
1492 bits = TEXGEN_EYE_LINEAR;
1493 break;
1494 case GL_REFLECTION_MAP_NV:
1495 bits = TEXGEN_REFLECTION_MAP_NV;
1496 break;
1497 case GL_NORMAL_MAP_NV:
1498 bits = TEXGEN_NORMAL_MAP_NV;
1499 break;
1500 case GL_SPHERE_MAP:
1501 bits = TEXGEN_SPHERE_MAP;
1502 break;
1503 default:
1504 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1505 return;
1506 }
1507 if (texUnit->GenModeS == mode)
1508 return;
1509 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1510 texUnit->GenModeS = mode;
1511 texUnit->_GenBitS = bits;
1512 }
1513 else if (pname==GL_OBJECT_PLANE) {
1514 if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
1515 return;
1516 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1517 texUnit->ObjectPlaneS[0] = params[0];
1518 texUnit->ObjectPlaneS[1] = params[1];
1519 texUnit->ObjectPlaneS[2] = params[2];
1520 texUnit->ObjectPlaneS[3] = params[3];
1521 }
1522 else if (pname==GL_EYE_PLANE) {
1523 GLfloat tmp[4];
1524
1525 /* Transform plane equation by the inverse modelview matrix */
1526 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1527 _math_matrix_analyse( &ctx->ModelView );
1528 }
1529 _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1530 if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
1531 return;
1532 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1533 COPY_4FV(texUnit->EyePlaneS, tmp);
1534 }
1535 else {
1536 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1537 return;
1538 }
1539 break;
1540 case GL_T:
1541 if (pname==GL_TEXTURE_GEN_MODE) {
1542 GLenum mode = (GLenum) (GLint) *params;
1543 GLuint bitt;
1544 switch (mode) {
1545 case GL_OBJECT_LINEAR:
1546 bitt = TEXGEN_OBJ_LINEAR;
1547 break;
1548 case GL_EYE_LINEAR:
1549 bitt = TEXGEN_EYE_LINEAR;
1550 break;
1551 case GL_REFLECTION_MAP_NV:
1552 bitt = TEXGEN_REFLECTION_MAP_NV;
1553 break;
1554 case GL_NORMAL_MAP_NV:
1555 bitt = TEXGEN_NORMAL_MAP_NV;
1556 break;
1557 case GL_SPHERE_MAP:
1558 bitt = TEXGEN_SPHERE_MAP;
1559 break;
1560 default:
1561 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1562 return;
1563 }
1564 if (texUnit->GenModeT == mode)
1565 return;
1566 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1567 texUnit->GenModeT = mode;
1568 texUnit->_GenBitT = bitt;
1569 }
1570 else if (pname==GL_OBJECT_PLANE) {
1571 if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
1572 return;
1573 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1574 texUnit->ObjectPlaneT[0] = params[0];
1575 texUnit->ObjectPlaneT[1] = params[1];
1576 texUnit->ObjectPlaneT[2] = params[2];
1577 texUnit->ObjectPlaneT[3] = params[3];
1578 }
1579 else if (pname==GL_EYE_PLANE) {
1580 GLfloat tmp[4];
1581 /* Transform plane equation by the inverse modelview matrix */
1582 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1583 _math_matrix_analyse( &ctx->ModelView );
1584 }
1585 _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1586 if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
1587 return;
1588 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1589 COPY_4FV(texUnit->EyePlaneT, tmp);
1590 }
1591 else {
1592 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1593 return;
1594 }
1595 break;
1596 case GL_R:
1597 if (pname==GL_TEXTURE_GEN_MODE) {
1598 GLenum mode = (GLenum) (GLint) *params;
1599 GLuint bitr;
1600 switch (mode) {
1601 case GL_OBJECT_LINEAR:
1602 bitr = TEXGEN_OBJ_LINEAR;
1603 break;
1604 case GL_REFLECTION_MAP_NV:
1605 bitr = TEXGEN_REFLECTION_MAP_NV;
1606 break;
1607 case GL_NORMAL_MAP_NV:
1608 bitr = TEXGEN_NORMAL_MAP_NV;
1609 break;
1610 case GL_EYE_LINEAR:
1611 bitr = TEXGEN_EYE_LINEAR;
1612 break;
1613 default:
1614 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1615 return;
1616 }
1617 if (texUnit->GenModeR == mode)
1618 return;
1619 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1620 texUnit->GenModeR = mode;
1621 texUnit->_GenBitR = bitr;
1622 }
1623 else if (pname==GL_OBJECT_PLANE) {
1624 if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
1625 return;
1626 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1627 texUnit->ObjectPlaneR[0] = params[0];
1628 texUnit->ObjectPlaneR[1] = params[1];
1629 texUnit->ObjectPlaneR[2] = params[2];
1630 texUnit->ObjectPlaneR[3] = params[3];
1631 }
1632 else if (pname==GL_EYE_PLANE) {
1633 GLfloat tmp[4];
1634 /* Transform plane equation by the inverse modelview matrix */
1635 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1636 _math_matrix_analyse( &ctx->ModelView );
1637 }
1638 _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1639 if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
1640 return;
1641 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1642 COPY_4FV(texUnit->EyePlaneR, tmp);
1643 }
1644 else {
1645 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1646 return;
1647 }
1648 break;
1649 case GL_Q:
1650 if (pname==GL_TEXTURE_GEN_MODE) {
1651 GLenum mode = (GLenum) (GLint) *params;
1652 GLuint bitq;
1653 switch (mode) {
1654 case GL_OBJECT_LINEAR:
1655 bitq = TEXGEN_OBJ_LINEAR;
1656 break;
1657 case GL_EYE_LINEAR:
1658 bitq = TEXGEN_EYE_LINEAR;
1659 break;
1660 default:
1661 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1662 return;
1663 }
1664 if (texUnit->GenModeQ == mode)
1665 return;
1666 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1667 texUnit->GenModeQ = mode;
1668 texUnit->_GenBitQ = bitq;
1669 }
1670 else if (pname==GL_OBJECT_PLANE) {
1671 if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
1672 return;
1673 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1674 texUnit->ObjectPlaneQ[0] = params[0];
1675 texUnit->ObjectPlaneQ[1] = params[1];
1676 texUnit->ObjectPlaneQ[2] = params[2];
1677 texUnit->ObjectPlaneQ[3] = params[3];
1678 }
1679 else if (pname==GL_EYE_PLANE) {
1680 GLfloat tmp[4];
1681 /* Transform plane equation by the inverse modelview matrix */
1682 if (ctx->ModelView.flags & MAT_DIRTY_INVERSE) {
1683 _math_matrix_analyse( &ctx->ModelView );
1684 }
1685 _mesa_transform_vector( tmp, params, ctx->ModelView.inv );
1686 if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
1687 return;
1688 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1689 COPY_4FV(texUnit->EyePlaneQ, tmp);
1690 }
1691 else {
1692 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1693 return;
1694 }
1695 break;
1696 default:
1697 _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
1698 return;
1699 }
1700
1701 if (ctx->Driver.TexGen)
1702 ctx->Driver.TexGen( ctx, coord, pname, params );
1703 }
1704
1705
1706 void
1707 _mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
1708 {
1709 GLfloat p[4];
1710 p[0] = params[0];
1711 p[1] = params[1];
1712 p[2] = params[2];
1713 p[3] = params[3];
1714 _mesa_TexGenfv(coord, pname, p);
1715 }
1716
1717
1718 void
1719 _mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
1720 {
1721 GLfloat p = (GLfloat) param;
1722 _mesa_TexGenfv( coord, pname, &p );
1723 }
1724
1725
1726 void
1727 _mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
1728 {
1729 GLfloat p[4];
1730 p[0] = params[0];
1731 p[1] = params[1];
1732 p[2] = params[2];
1733 p[3] = params[3];
1734 _mesa_TexGenfv( coord, pname, p );
1735 }
1736
1737
1738 void
1739 _mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
1740 {
1741 _mesa_TexGenfv(coord, pname, &param);
1742 }
1743
1744
1745 void
1746 _mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
1747 {
1748 _mesa_TexGeniv( coord, pname, &param );
1749 }
1750
1751
1752
1753 void
1754 _mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
1755 {
1756 GET_CURRENT_CONTEXT(ctx);
1757 GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1758 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1759 ASSERT_OUTSIDE_BEGIN_END(ctx);
1760
1761 switch (coord) {
1762 case GL_S:
1763 if (pname==GL_TEXTURE_GEN_MODE) {
1764 params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
1765 }
1766 else if (pname==GL_OBJECT_PLANE) {
1767 COPY_4V( params, texUnit->ObjectPlaneS );
1768 }
1769 else if (pname==GL_EYE_PLANE) {
1770 COPY_4V( params, texUnit->EyePlaneS );
1771 }
1772 else {
1773 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1774 return;
1775 }
1776 break;
1777 case GL_T:
1778 if (pname==GL_TEXTURE_GEN_MODE) {
1779 params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
1780 }
1781 else if (pname==GL_OBJECT_PLANE) {
1782 COPY_4V( params, texUnit->ObjectPlaneT );
1783 }
1784 else if (pname==GL_EYE_PLANE) {
1785 COPY_4V( params, texUnit->EyePlaneT );
1786 }
1787 else {
1788 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1789 return;
1790 }
1791 break;
1792 case GL_R:
1793 if (pname==GL_TEXTURE_GEN_MODE) {
1794 params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
1795 }
1796 else if (pname==GL_OBJECT_PLANE) {
1797 COPY_4V( params, texUnit->ObjectPlaneR );
1798 }
1799 else if (pname==GL_EYE_PLANE) {
1800 COPY_4V( params, texUnit->EyePlaneR );
1801 }
1802 else {
1803 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1804 return;
1805 }
1806 break;
1807 case GL_Q:
1808 if (pname==GL_TEXTURE_GEN_MODE) {
1809 params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
1810 }
1811 else if (pname==GL_OBJECT_PLANE) {
1812 COPY_4V( params, texUnit->ObjectPlaneQ );
1813 }
1814 else if (pname==GL_EYE_PLANE) {
1815 COPY_4V( params, texUnit->EyePlaneQ );
1816 }
1817 else {
1818 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
1819 return;
1820 }
1821 break;
1822 default:
1823 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
1824 return;
1825 }
1826 }
1827
1828
1829
1830 void
1831 _mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
1832 {
1833 GET_CURRENT_CONTEXT(ctx);
1834 GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1835 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1836 ASSERT_OUTSIDE_BEGIN_END(ctx);
1837
1838 switch (coord) {
1839 case GL_S:
1840 if (pname==GL_TEXTURE_GEN_MODE) {
1841 params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
1842 }
1843 else if (pname==GL_OBJECT_PLANE) {
1844 COPY_4V( params, texUnit->ObjectPlaneS );
1845 }
1846 else if (pname==GL_EYE_PLANE) {
1847 COPY_4V( params, texUnit->EyePlaneS );
1848 }
1849 else {
1850 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1851 return;
1852 }
1853 break;
1854 case GL_T:
1855 if (pname==GL_TEXTURE_GEN_MODE) {
1856 params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
1857 }
1858 else if (pname==GL_OBJECT_PLANE) {
1859 COPY_4V( params, texUnit->ObjectPlaneT );
1860 }
1861 else if (pname==GL_EYE_PLANE) {
1862 COPY_4V( params, texUnit->EyePlaneT );
1863 }
1864 else {
1865 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1866 return;
1867 }
1868 break;
1869 case GL_R:
1870 if (pname==GL_TEXTURE_GEN_MODE) {
1871 params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
1872 }
1873 else if (pname==GL_OBJECT_PLANE) {
1874 COPY_4V( params, texUnit->ObjectPlaneR );
1875 }
1876 else if (pname==GL_EYE_PLANE) {
1877 COPY_4V( params, texUnit->EyePlaneR );
1878 }
1879 else {
1880 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1881 return;
1882 }
1883 break;
1884 case GL_Q:
1885 if (pname==GL_TEXTURE_GEN_MODE) {
1886 params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
1887 }
1888 else if (pname==GL_OBJECT_PLANE) {
1889 COPY_4V( params, texUnit->ObjectPlaneQ );
1890 }
1891 else if (pname==GL_EYE_PLANE) {
1892 COPY_4V( params, texUnit->EyePlaneQ );
1893 }
1894 else {
1895 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
1896 return;
1897 }
1898 break;
1899 default:
1900 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
1901 return;
1902 }
1903 }
1904
1905
1906
1907 void
1908 _mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
1909 {
1910 GET_CURRENT_CONTEXT(ctx);
1911 GLuint tUnit = ctx->Texture.CurrentTransformUnit;
1912 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1913 ASSERT_OUTSIDE_BEGIN_END(ctx);
1914
1915 switch (coord) {
1916 case GL_S:
1917 if (pname==GL_TEXTURE_GEN_MODE) {
1918 params[0] = texUnit->GenModeS;
1919 }
1920 else if (pname==GL_OBJECT_PLANE) {
1921 params[0] = (GLint) texUnit->ObjectPlaneS[0];
1922 params[1] = (GLint) texUnit->ObjectPlaneS[1];
1923 params[2] = (GLint) texUnit->ObjectPlaneS[2];
1924 params[3] = (GLint) texUnit->ObjectPlaneS[3];
1925 }
1926 else if (pname==GL_EYE_PLANE) {
1927 params[0] = (GLint) texUnit->EyePlaneS[0];
1928 params[1] = (GLint) texUnit->EyePlaneS[1];
1929 params[2] = (GLint) texUnit->EyePlaneS[2];
1930 params[3] = (GLint) texUnit->EyePlaneS[3];
1931 }
1932 else {
1933 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1934 return;
1935 }
1936 break;
1937 case GL_T:
1938 if (pname==GL_TEXTURE_GEN_MODE) {
1939 params[0] = texUnit->GenModeT;
1940 }
1941 else if (pname==GL_OBJECT_PLANE) {
1942 params[0] = (GLint) texUnit->ObjectPlaneT[0];
1943 params[1] = (GLint) texUnit->ObjectPlaneT[1];
1944 params[2] = (GLint) texUnit->ObjectPlaneT[2];
1945 params[3] = (GLint) texUnit->ObjectPlaneT[3];
1946 }
1947 else if (pname==GL_EYE_PLANE) {
1948 params[0] = (GLint) texUnit->EyePlaneT[0];
1949 params[1] = (GLint) texUnit->EyePlaneT[1];
1950 params[2] = (GLint) texUnit->EyePlaneT[2];
1951 params[3] = (GLint) texUnit->EyePlaneT[3];
1952 }
1953 else {
1954 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1955 return;
1956 }
1957 break;
1958 case GL_R:
1959 if (pname==GL_TEXTURE_GEN_MODE) {
1960 params[0] = texUnit->GenModeR;
1961 }
1962 else if (pname==GL_OBJECT_PLANE) {
1963 params[0] = (GLint) texUnit->ObjectPlaneR[0];
1964 params[1] = (GLint) texUnit->ObjectPlaneR[1];
1965 params[2] = (GLint) texUnit->ObjectPlaneR[2];
1966 params[3] = (GLint) texUnit->ObjectPlaneR[3];
1967 }
1968 else if (pname==GL_EYE_PLANE) {
1969 params[0] = (GLint) texUnit->EyePlaneR[0];
1970 params[1] = (GLint) texUnit->EyePlaneR[1];
1971 params[2] = (GLint) texUnit->EyePlaneR[2];
1972 params[3] = (GLint) texUnit->EyePlaneR[3];
1973 }
1974 else {
1975 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1976 return;
1977 }
1978 break;
1979 case GL_Q:
1980 if (pname==GL_TEXTURE_GEN_MODE) {
1981 params[0] = texUnit->GenModeQ;
1982 }
1983 else if (pname==GL_OBJECT_PLANE) {
1984 params[0] = (GLint) texUnit->ObjectPlaneQ[0];
1985 params[1] = (GLint) texUnit->ObjectPlaneQ[1];
1986 params[2] = (GLint) texUnit->ObjectPlaneQ[2];
1987 params[3] = (GLint) texUnit->ObjectPlaneQ[3];
1988 }
1989 else if (pname==GL_EYE_PLANE) {
1990 params[0] = (GLint) texUnit->EyePlaneQ[0];
1991 params[1] = (GLint) texUnit->EyePlaneQ[1];
1992 params[2] = (GLint) texUnit->EyePlaneQ[2];
1993 params[3] = (GLint) texUnit->EyePlaneQ[3];
1994 }
1995 else {
1996 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
1997 return;
1998 }
1999 break;
2000 default:
2001 _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
2002 return;
2003 }
2004 }
2005
2006
2007 /* GL_ARB_multitexture */
2008 void
2009 _mesa_ActiveTextureARB( GLenum target )
2010 {
2011 GET_CURRENT_CONTEXT(ctx);
2012 GLuint texUnit = target - GL_TEXTURE0_ARB;
2013 ASSERT_OUTSIDE_BEGIN_END(ctx);
2014
2015 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
2016 fprintf(stderr, "glActiveTexture %s\n",
2017 _mesa_lookup_enum_by_nr(target));
2018
2019 if (texUnit > ctx->Const.MaxTextureUnits) {
2020 _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
2021 return;
2022 }
2023
2024 FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2025 ctx->Texture.CurrentUnit = texUnit;
2026 ctx->Texture.CurrentTransformUnit = texUnit;
2027 if (ctx->Driver.ActiveTexture) {
2028 (*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
2029 }
2030 }
2031
2032
2033 /* GL_ARB_multitexture */
2034 void
2035 _mesa_ClientActiveTextureARB( GLenum target )
2036 {
2037 GET_CURRENT_CONTEXT(ctx);
2038 GLuint texUnit = target - GL_TEXTURE0_ARB;
2039 ASSERT_OUTSIDE_BEGIN_END(ctx);
2040
2041 if (texUnit > ctx->Const.MaxTextureUnits) {
2042 _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
2043 return;
2044 }
2045
2046 FLUSH_VERTICES(ctx, _NEW_ARRAY);
2047 ctx->Array.ActiveTexture = texUnit;
2048 }