Subversion Repositories shark

Rev

Rev 55 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
55 pj 1
/* $Id: texstate.c,v 1.1 2003-02-28 11:42:05 pj Exp $ */
2
 
3
/*
4
 * Mesa 3-D graphics library
5
 * Version:  5.0
6
 *
7
 * Copyright (C) 1999-2002  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
#include "glheader.h"
29
#include "colormac.h"
30
#include "context.h"
31
#include "enums.h"
32
#include "extensions.h"
33
#include "macros.h"
34
#include "texobj.h"
35
#include "teximage.h"
36
#include "texstate.h"
37
#include "mtypes.h"
38
#include "math/m_xform.h"
39
#include "math/m_matrix.h"
40
 
41
 
42
 
43
#ifdef SPECIALCAST
44
/* Needed for an Amiga compiler */
45
#define ENUM_TO_FLOAT(X) ((GLfloat)(GLint)(X))
46
#define ENUM_TO_DOUBLE(X) ((GLdouble)(GLint)(X))
47
#else
48
/* all other compilers */
49
#define ENUM_TO_FLOAT(X) ((GLfloat)(X))
50
#define ENUM_TO_DOUBLE(X) ((GLdouble)(X))
51
#endif
52
 
53
 
54
 
55
void
56
_mesa_copy_texture_state( const GLcontext *src, GLcontext *dst )
57
{
58
   GLuint i;
59
 
60
   ASSERT(src);
61
   ASSERT(dst);
62
 
63
   dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
64
   dst->Texture._GenFlags = src->Texture._GenFlags;
65
   dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
66
   dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
67
   dst->Texture.SharedPalette = src->Texture.SharedPalette;
68
 
69
   /* per-unit state */
70
   for (i = 0; i < src->Const.MaxTextureUnits; i++) {
71
      dst->Texture.Unit[i].Enabled = src->Texture.Unit[i].Enabled;
72
      dst->Texture.Unit[i].EnvMode = src->Texture.Unit[i].EnvMode;
73
      COPY_4V(dst->Texture.Unit[i].EnvColor, src->Texture.Unit[i].EnvColor);
74
      dst->Texture.Unit[i].TexGenEnabled = src->Texture.Unit[i].TexGenEnabled;
75
      dst->Texture.Unit[i].GenModeS = src->Texture.Unit[i].GenModeS;
76
      dst->Texture.Unit[i].GenModeT = src->Texture.Unit[i].GenModeT;
77
      dst->Texture.Unit[i].GenModeR = src->Texture.Unit[i].GenModeR;
78
      dst->Texture.Unit[i].GenModeQ = src->Texture.Unit[i].GenModeQ;
79
      dst->Texture.Unit[i]._GenBitS = src->Texture.Unit[i]._GenBitS;
80
      dst->Texture.Unit[i]._GenBitT = src->Texture.Unit[i]._GenBitT;
81
      dst->Texture.Unit[i]._GenBitR = src->Texture.Unit[i]._GenBitR;
82
      dst->Texture.Unit[i]._GenBitQ = src->Texture.Unit[i]._GenBitQ;
83
      dst->Texture.Unit[i]._GenFlags = src->Texture.Unit[i]._GenFlags;
84
      COPY_4V(dst->Texture.Unit[i].ObjectPlaneS, src->Texture.Unit[i].ObjectPlaneS);
85
      COPY_4V(dst->Texture.Unit[i].ObjectPlaneT, src->Texture.Unit[i].ObjectPlaneT);
86
      COPY_4V(dst->Texture.Unit[i].ObjectPlaneR, src->Texture.Unit[i].ObjectPlaneR);
87
      COPY_4V(dst->Texture.Unit[i].ObjectPlaneQ, src->Texture.Unit[i].ObjectPlaneQ);
88
      COPY_4V(dst->Texture.Unit[i].EyePlaneS, src->Texture.Unit[i].EyePlaneS);
89
      COPY_4V(dst->Texture.Unit[i].EyePlaneT, src->Texture.Unit[i].EyePlaneT);
90
      COPY_4V(dst->Texture.Unit[i].EyePlaneR, src->Texture.Unit[i].EyePlaneR);
91
      COPY_4V(dst->Texture.Unit[i].EyePlaneQ, src->Texture.Unit[i].EyePlaneQ);
92
      dst->Texture.Unit[i].LodBias = src->Texture.Unit[i].LodBias;
93
 
94
      /* GL_EXT_texture_env_combine */
95
      dst->Texture.Unit[i].CombineModeRGB = src->Texture.Unit[i].CombineModeRGB;
96
      dst->Texture.Unit[i].CombineModeA = src->Texture.Unit[i].CombineModeA;
97
      COPY_3V(dst->Texture.Unit[i].CombineSourceRGB, src->Texture.Unit[i].CombineSourceRGB);
98
      COPY_3V(dst->Texture.Unit[i].CombineSourceA, src->Texture.Unit[i].CombineSourceA);
99
      COPY_3V(dst->Texture.Unit[i].CombineOperandRGB, src->Texture.Unit[i].CombineOperandRGB);
100
      COPY_3V(dst->Texture.Unit[i].CombineOperandA, src->Texture.Unit[i].CombineOperandA);
101
      dst->Texture.Unit[i].CombineScaleShiftRGB = src->Texture.Unit[i].CombineScaleShiftRGB;
102
      dst->Texture.Unit[i].CombineScaleShiftA = src->Texture.Unit[i].CombineScaleShiftA;
103
 
104
      /* texture object state */
105
      _mesa_copy_texture_object(dst->Texture.Unit[i].Current1D,
106
                                src->Texture.Unit[i].Current1D);
107
      _mesa_copy_texture_object(dst->Texture.Unit[i].Current2D,
108
                                src->Texture.Unit[i].Current2D);
109
      _mesa_copy_texture_object(dst->Texture.Unit[i].Current3D,
110
                                src->Texture.Unit[i].Current3D);
111
      _mesa_copy_texture_object(dst->Texture.Unit[i].CurrentCubeMap,
112
                                src->Texture.Unit[i].CurrentCubeMap);
113
      _mesa_copy_texture_object(dst->Texture.Unit[i].CurrentRect,
114
                                src->Texture.Unit[i].CurrentRect);
115
   }
116
}
117
 
118
 
119
/**********************************************************************/
120
/*                       Texture Environment                          */
121
/**********************************************************************/
122
 
123
 
124
void
125
_mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
126
{
127
   GET_CURRENT_CONTEXT(ctx);
128
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
129
   ASSERT_OUTSIDE_BEGIN_END(ctx);
130
 
131
#define TE_ERROR(errCode, msg, value)                           \
132
   _mesa_error(ctx, errCode, msg, _mesa_lookup_enum_by_nr(value));
133
 
134
   if (target == GL_TEXTURE_ENV) {
135
      switch (pname) {
136
      case GL_TEXTURE_ENV_MODE:
137
         {
138
            const GLenum mode = (GLenum) (GLint) *param;
139
            if (mode == GL_MODULATE ||
140
                mode == GL_BLEND ||
141
                mode == GL_DECAL ||
142
                mode == GL_REPLACE ||
143
                (mode == GL_ADD && ctx->Extensions.EXT_texture_env_add) ||
144
                (mode == GL_COMBINE_EXT &&
145
                 (ctx->Extensions.EXT_texture_env_combine ||
146
                  ctx->Extensions.ARB_texture_env_combine))) {
147
               /* legal */
148
               if (texUnit->EnvMode == mode)
149
                  return;
150
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
151
               texUnit->EnvMode = mode;
152
            }
153
            else {
154
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
155
               return;
156
            }
157
         }
158
         break;
159
      case GL_TEXTURE_ENV_COLOR:
160
         {
161
            GLfloat tmp[4];
162
            tmp[0] = CLAMP( param[0], 0.0F, 1.0F );
163
            tmp[1] = CLAMP( param[1], 0.0F, 1.0F );
164
            tmp[2] = CLAMP( param[2], 0.0F, 1.0F );
165
            tmp[3] = CLAMP( param[3], 0.0F, 1.0F );
166
            if (TEST_EQ_4V(tmp, texUnit->EnvColor))
167
               return;
168
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
169
            COPY_4FV(texUnit->EnvColor, tmp);
170
         }
171
         break;
172
      case GL_COMBINE_RGB_EXT:
173
         if (ctx->Extensions.EXT_texture_env_combine ||
174
             ctx->Extensions.ARB_texture_env_combine) {
175
            const GLenum mode = (GLenum) (GLint) *param;
176
            switch (mode) {
177
            case GL_REPLACE:
178
            case GL_MODULATE:
179
            case GL_ADD:
180
            case GL_ADD_SIGNED_EXT:
181
            case GL_INTERPOLATE_EXT:
182
               /* OK */
183
               break;
184
            case GL_SUBTRACT_ARB:
185
               if (!ctx->Extensions.ARB_texture_env_combine) {
186
                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
187
                  return;
188
               }
189
               break;
190
            case GL_DOT3_RGB_EXT:
191
            case GL_DOT3_RGBA_EXT:
192
               if (!ctx->Extensions.EXT_texture_env_dot3) {
193
                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
194
                  return;
195
               }
196
               break;
197
            case GL_DOT3_RGB_ARB:
198
            case GL_DOT3_RGBA_ARB:
199
               if (!ctx->Extensions.ARB_texture_env_dot3) {
200
                  TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
201
                  return;
202
               }
203
               break;
204
            default:
205
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
206
               return;
207
            }
208
            if (texUnit->CombineModeRGB == mode)
209
               return;
210
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
211
            texUnit->CombineModeRGB = mode;
212
         }
213
         else {
214
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
215
            return;
216
         }
217
         break;
218
      case GL_COMBINE_ALPHA_EXT:
219
         if (ctx->Extensions.EXT_texture_env_combine ||
220
             ctx->Extensions.ARB_texture_env_combine) {
221
            const GLenum mode = (GLenum) (GLint) *param;
222
            if (mode == GL_REPLACE ||
223
                mode == GL_MODULATE ||
224
                mode == GL_ADD ||
225
                mode == GL_ADD_SIGNED_EXT ||
226
                mode == GL_INTERPOLATE_EXT ||
227
                (mode == GL_SUBTRACT_ARB &&
228
                 ctx->Extensions.ARB_texture_env_combine)) {
229
               /* legal */
230
               if (texUnit->CombineModeA == mode)
231
                  return;
232
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
233
               texUnit->CombineModeA = mode;
234
            }
235
            else {
236
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", mode);
237
               return;
238
            }
239
         }
240
         else {
241
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
242
            return;
243
         }
244
         break;
245
      case GL_SOURCE0_RGB_EXT:
246
      case GL_SOURCE1_RGB_EXT:
247
      case GL_SOURCE2_RGB_EXT:
248
         if (ctx->Extensions.EXT_texture_env_combine ||
249
             ctx->Extensions.ARB_texture_env_combine) {
250
            const GLenum source = (GLenum) (GLint) *param;
251
            const GLuint s = pname - GL_SOURCE0_RGB_EXT;
252
            if (source == GL_TEXTURE ||
253
                source == GL_CONSTANT_EXT ||
254
                source == GL_PRIMARY_COLOR_EXT ||
255
                source == GL_PREVIOUS_EXT ||
256
                (ctx->Extensions.ARB_texture_env_crossbar &&
257
                 source >= GL_TEXTURE0_ARB &&
258
                 source < GL_TEXTURE0_ARB + ctx->Const.MaxTextureUnits)) {
259
               /* legal */
260
               if (texUnit->CombineSourceRGB[s] == source)
261
                  return;
262
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
263
               texUnit->CombineSourceRGB[s] = source;
264
            }
265
            else {
266
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
267
               return;
268
            }
269
         }
270
         else {
271
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
272
            return;
273
         }
274
         break;
275
      case GL_SOURCE0_ALPHA_EXT:
276
      case GL_SOURCE1_ALPHA_EXT:
277
      case GL_SOURCE2_ALPHA_EXT:
278
         if (ctx->Extensions.EXT_texture_env_combine ||
279
             ctx->Extensions.ARB_texture_env_combine) {
280
            const GLenum source = (GLenum) (GLint) *param;
281
            const GLuint s = pname - GL_SOURCE0_ALPHA_EXT;
282
            if (source == GL_TEXTURE ||
283
                source == GL_CONSTANT_EXT ||
284
                source == GL_PRIMARY_COLOR_EXT ||
285
                source == GL_PREVIOUS_EXT ||
286
                (ctx->Extensions.ARB_texture_env_crossbar &&
287
                 source >= GL_TEXTURE0_ARB &&
288
                 source < GL_TEXTURE0_ARB + ctx->Const.MaxTextureUnits)) {
289
               /* legal */
290
               if (texUnit->CombineSourceA[s] == source)
291
                  return;
292
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
293
               texUnit->CombineSourceA[s] = source;
294
            }
295
            else {
296
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", source);
297
               return;
298
            }
299
         }
300
         else {
301
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
302
            return;
303
         }
304
         break;
305
      case GL_OPERAND0_RGB_EXT:
306
      case GL_OPERAND1_RGB_EXT:
307
         if (ctx->Extensions.EXT_texture_env_combine ||
308
             ctx->Extensions.ARB_texture_env_combine) {
309
            const GLenum operand = (GLenum) (GLint) *param;
310
            const GLuint s = pname - GL_OPERAND0_RGB_EXT;
311
            switch (operand) {
312
            case GL_SRC_COLOR:
313
            case GL_ONE_MINUS_SRC_COLOR:
314
            case GL_SRC_ALPHA:
315
            case GL_ONE_MINUS_SRC_ALPHA:
316
               if (texUnit->CombineOperandRGB[s] == operand)
317
                  return;
318
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
319
               texUnit->CombineOperandRGB[s] = operand;
320
               break;
321
            default:
322
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
323
               return;
324
            }
325
         }
326
         else {
327
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
328
            return;
329
         }
330
         break;
331
      case GL_OPERAND0_ALPHA_EXT:
332
      case GL_OPERAND1_ALPHA_EXT:
333
         if (ctx->Extensions.EXT_texture_env_combine ||
334
             ctx->Extensions.ARB_texture_env_combine) {
335
            const GLenum operand = (GLenum) (GLint) *param;
336
            switch (operand) {
337
            case GL_SRC_ALPHA:
338
            case GL_ONE_MINUS_SRC_ALPHA:
339
               if (texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] ==
340
                   operand)
341
                  return;
342
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
343
               texUnit->CombineOperandA[pname-GL_OPERAND0_ALPHA_EXT] = operand;
344
               break;
345
            default:
346
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
347
               return;
348
            }
349
         }
350
         else {
351
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
352
            return;
353
         }
354
         break;
355
      case GL_OPERAND2_RGB_EXT:
356
         if (ctx->Extensions.EXT_texture_env_combine ||
357
             ctx->Extensions.ARB_texture_env_combine) {
358
            const GLenum operand = (GLenum) (GLint) *param;
359
            switch (operand) {
360
            case GL_SRC_COLOR:           /* ARB combine only */
361
            case GL_ONE_MINUS_SRC_COLOR: /* ARB combine only */
362
            case GL_SRC_ALPHA:
363
            case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
364
               if (texUnit->CombineOperandRGB[2] == operand)
365
                  return;
366
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
367
               texUnit->CombineOperandRGB[2] = operand;
368
            default:
369
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
370
               return;
371
            }
372
         }
373
         else {
374
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
375
            return;
376
         }
377
         break;
378
      case GL_OPERAND2_ALPHA_EXT:
379
         if (ctx->Extensions.EXT_texture_env_combine ||
380
             ctx->Extensions.ARB_texture_env_combine) {
381
            const GLenum operand = (GLenum) (GLint) *param;
382
            switch (operand) {
383
            case GL_SRC_ALPHA:
384
            case GL_ONE_MINUS_SRC_ALPHA: /* ARB combine only */
385
               if (texUnit->CombineOperandA[2] == operand)
386
                  return;
387
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
388
               texUnit->CombineOperandA[2] = operand;
389
               break;
390
            default:
391
               TE_ERROR(GL_INVALID_ENUM, "glTexEnv(param=%s)", operand);
392
               return;
393
            }
394
         }
395
         else {
396
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
397
            return;
398
         }
399
         break;
400
      case GL_RGB_SCALE_EXT:
401
         if (ctx->Extensions.EXT_texture_env_combine ||
402
             ctx->Extensions.ARB_texture_env_combine) {
403
            GLuint newshift;
404
            if (*param == 1.0) {
405
               newshift = 0;
406
            }
407
            else if (*param == 2.0) {
408
               newshift = 1;
409
            }
410
            else if (*param == 4.0) {
411
               newshift = 2;
412
            }
413
            else {
414
               _mesa_error( ctx, GL_INVALID_VALUE,
415
                            "glTexEnv(GL_RGB_SCALE not 1, 2 or 4)" );
416
               return;
417
            }
418
            if (texUnit->CombineScaleShiftRGB == newshift)
419
               return;
420
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
421
            texUnit->CombineScaleShiftRGB = newshift;
422
         }
423
         else {
424
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
425
            return;
426
         }
427
         break;
428
      case GL_ALPHA_SCALE:
429
         if (ctx->Extensions.EXT_texture_env_combine ||
430
             ctx->Extensions.ARB_texture_env_combine) {
431
            GLuint newshift;
432
            if (*param == 1.0) {
433
               newshift = 0;
434
            }
435
            else if (*param == 2.0) {
436
               newshift = 1;
437
            }
438
            else if (*param == 4.0) {
439
               newshift = 2;
440
            }
441
            else {
442
               _mesa_error( ctx, GL_INVALID_VALUE,
443
                            "glTexEnv(GL_ALPHA_SCALE not 1, 2 or 4)" );
444
               return;
445
            }
446
            if (texUnit->CombineScaleShiftA == newshift)
447
               return;
448
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
449
            texUnit->CombineScaleShiftA = newshift;
450
         }
451
         else {
452
            TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
453
            return;
454
         }
455
         break;
456
      default:
457
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname)" );
458
         return;
459
      }
460
   }
461
   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
462
      /* GL_EXT_texture_lod_bias */
463
      if (!ctx->Extensions.EXT_texture_lod_bias) {
464
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
465
         return;
466
      }
467
      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
468
         if (texUnit->LodBias == param[0])
469
            return;
470
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
471
         texUnit->LodBias = CLAMP(param[0], -ctx->Const.MaxTextureLodBias,
472
                                  ctx->Const.MaxTextureLodBias);
473
      }
474
      else {
475
         TE_ERROR(GL_INVALID_ENUM, "glTexEnv(pname=%s)", pname);
476
         return;
477
      }
478
   }
479
   else if (target == GL_POINT_SPRITE_NV) {
480
      /* GL_NV_point_sprite */
481
      if (!ctx->Extensions.NV_point_sprite) {
482
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)", target );
483
         return;
484
      }
485
      if (pname == GL_COORD_REPLACE_NV) {
486
         const GLenum value = (GLenum) param[0];
487
         if (value == GL_TRUE || value == GL_FALSE) {
488
            /* It's kind of weird to set point state via glTexEnv,
489
             * but that's what the spec calls for.
490
             */
491
            const GLboolean state = (GLboolean) value;
492
            if (ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] == state)
493
               return;
494
            FLUSH_VERTICES(ctx, _NEW_POINT);
495
            ctx->Point.CoordReplace[ctx->Texture.CurrentUnit] = state;
496
         }
497
         else {
498
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexEnv(param=0x%x)", value);
499
            return;
500
         }
501
      }
502
      else {
503
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(pname=0x%x)", pname );
504
         return;
505
      }
506
   }
507
   else {
508
      _mesa_error( ctx, GL_INVALID_ENUM, "glTexEnv(target=0x%x)",target );
509
      return;
510
   }
511
 
512
   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
513
      _mesa_debug(ctx, "glTexEnv %s %s %.1f(%s) ...\n",
514
                  _mesa_lookup_enum_by_nr(target),
515
                  _mesa_lookup_enum_by_nr(pname),
516
                  *param,
517
                  _mesa_lookup_enum_by_nr((GLenum) (GLint) *param));
518
 
519
   /* Tell device driver about the new texture environment */
520
   if (ctx->Driver.TexEnv) {
521
      (*ctx->Driver.TexEnv)( ctx, target, pname, param );
522
   }
523
}
524
 
525
 
526
void
527
_mesa_TexEnvf( GLenum target, GLenum pname, GLfloat param )
528
{
529
   _mesa_TexEnvfv( target, pname, &param );
530
}
531
 
532
 
533
 
534
void
535
_mesa_TexEnvi( GLenum target, GLenum pname, GLint param )
536
{
537
   GLfloat p[4];
538
   p[0] = (GLfloat) param;
539
   p[1] = p[2] = p[3] = 0.0;
540
   _mesa_TexEnvfv( target, pname, p );
541
}
542
 
543
 
544
void
545
_mesa_TexEnviv( GLenum target, GLenum pname, const GLint *param )
546
{
547
   GLfloat p[4];
548
   if (pname == GL_TEXTURE_ENV_COLOR) {
549
      p[0] = INT_TO_FLOAT( param[0] );
550
      p[1] = INT_TO_FLOAT( param[1] );
551
      p[2] = INT_TO_FLOAT( param[2] );
552
      p[3] = INT_TO_FLOAT( param[3] );
553
   }
554
   else {
555
      p[0] = (GLfloat) param[0];
556
      p[1] = p[2] = p[3] = 0;  /* init to zero, just to be safe */
557
   }
558
   _mesa_TexEnvfv( target, pname, p );
559
}
560
 
561
 
562
void
563
_mesa_GetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
564
{
565
   GET_CURRENT_CONTEXT(ctx);
566
   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
567
   ASSERT_OUTSIDE_BEGIN_END(ctx);
568
 
569
   if (target == GL_TEXTURE_ENV) {
570
      switch (pname) {
571
         case GL_TEXTURE_ENV_MODE:
572
            *params = ENUM_TO_FLOAT(texUnit->EnvMode);
573
            break;
574
         case GL_TEXTURE_ENV_COLOR:
575
            COPY_4FV( params, texUnit->EnvColor );
576
            break;
577
         case GL_COMBINE_RGB_EXT:
578
            if (ctx->Extensions.EXT_texture_env_combine ||
579
                ctx->Extensions.ARB_texture_env_combine) {
580
               *params = (GLfloat) texUnit->CombineModeRGB;
581
            }
582
            else {
583
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
584
            }
585
            break;
586
         case GL_COMBINE_ALPHA_EXT:
587
            if (ctx->Extensions.EXT_texture_env_combine ||
588
                ctx->Extensions.ARB_texture_env_combine) {
589
               *params = (GLfloat) texUnit->CombineModeA;
590
            }
591
            else {
592
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
593
            }
594
            break;
595
         case GL_SOURCE0_RGB_EXT:
596
            if (ctx->Extensions.EXT_texture_env_combine ||
597
                ctx->Extensions.ARB_texture_env_combine) {
598
               *params = (GLfloat) texUnit->CombineSourceRGB[0];
599
            }
600
            else {
601
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
602
            }
603
            break;
604
         case GL_SOURCE1_RGB_EXT:
605
            if (ctx->Extensions.EXT_texture_env_combine ||
606
                ctx->Extensions.ARB_texture_env_combine) {
607
               *params = (GLfloat) texUnit->CombineSourceRGB[1];
608
            }
609
            else {
610
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
611
            }
612
            break;
613
         case GL_SOURCE2_RGB_EXT:
614
            if (ctx->Extensions.EXT_texture_env_combine ||
615
                ctx->Extensions.ARB_texture_env_combine) {
616
               *params = (GLfloat) texUnit->CombineSourceRGB[2];
617
            }
618
            else {
619
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
620
            }
621
            break;
622
         case GL_SOURCE0_ALPHA_EXT:
623
            if (ctx->Extensions.EXT_texture_env_combine ||
624
                ctx->Extensions.ARB_texture_env_combine) {
625
               *params = (GLfloat) texUnit->CombineSourceA[0];
626
            }
627
            else {
628
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
629
            }
630
            break;
631
         case GL_SOURCE1_ALPHA_EXT:
632
            if (ctx->Extensions.EXT_texture_env_combine ||
633
                ctx->Extensions.ARB_texture_env_combine) {
634
               *params = (GLfloat) texUnit->CombineSourceA[1];
635
            }
636
            else {
637
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
638
            }
639
            break;
640
         case GL_SOURCE2_ALPHA_EXT:
641
            if (ctx->Extensions.EXT_texture_env_combine ||
642
                ctx->Extensions.ARB_texture_env_combine) {
643
               *params = (GLfloat) texUnit->CombineSourceA[2];
644
            }
645
            else {
646
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
647
            }
648
            break;
649
         case GL_OPERAND0_RGB_EXT:
650
            if (ctx->Extensions.EXT_texture_env_combine ||
651
                ctx->Extensions.ARB_texture_env_combine) {
652
               *params = (GLfloat) texUnit->CombineOperandRGB[0];
653
            }
654
            else {
655
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
656
            }
657
            break;
658
         case GL_OPERAND1_RGB_EXT:
659
            if (ctx->Extensions.EXT_texture_env_combine ||
660
                ctx->Extensions.ARB_texture_env_combine) {
661
               *params = (GLfloat) texUnit->CombineOperandRGB[1];
662
            }
663
            else {
664
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
665
            }
666
            break;
667
         case GL_OPERAND2_RGB_EXT:
668
            if (ctx->Extensions.EXT_texture_env_combine ||
669
                ctx->Extensions.ARB_texture_env_combine) {
670
               *params = (GLfloat) texUnit->CombineOperandRGB[2];
671
            }
672
            else {
673
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
674
            }
675
            break;
676
         case GL_OPERAND0_ALPHA_EXT:
677
            if (ctx->Extensions.EXT_texture_env_combine ||
678
                ctx->Extensions.ARB_texture_env_combine) {
679
               *params = (GLfloat) texUnit->CombineOperandA[0];
680
            }
681
            else {
682
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
683
            }
684
            break;
685
         case GL_OPERAND1_ALPHA_EXT:
686
            if (ctx->Extensions.EXT_texture_env_combine ||
687
                ctx->Extensions.ARB_texture_env_combine) {
688
               *params = (GLfloat) texUnit->CombineOperandA[1];
689
            }
690
            else {
691
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
692
            }
693
            break;
694
         case GL_OPERAND2_ALPHA_EXT:
695
            if (ctx->Extensions.EXT_texture_env_combine ||
696
                ctx->Extensions.ARB_texture_env_combine) {
697
               *params = (GLfloat) texUnit->CombineOperandA[2];
698
            }
699
            else {
700
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
701
            }
702
            break;
703
         case GL_RGB_SCALE_EXT:
704
            if (ctx->Extensions.EXT_texture_env_combine ||
705
                ctx->Extensions.ARB_texture_env_combine) {
706
               if (texUnit->CombineScaleShiftRGB == 0)
707
                  *params = 1.0;
708
               else if (texUnit->CombineScaleShiftRGB == 1)
709
                  *params = 2.0;
710
               else
711
                  *params = 4.0;
712
            }
713
            else {
714
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
715
               return;
716
            }
717
            break;
718
         case GL_ALPHA_SCALE:
719
            if (ctx->Extensions.EXT_texture_env_combine ||
720
                ctx->Extensions.ARB_texture_env_combine) {
721
               if (texUnit->CombineScaleShiftA == 0)
722
                  *params = 1.0;
723
               else if (texUnit->CombineScaleShiftA == 1)
724
                  *params = 2.0;
725
               else
726
                  *params = 4.0;
727
            }
728
            else {
729
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)");
730
               return;
731
            }
732
            break;
733
         default:
734
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
735
      }
736
   }
737
   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
738
      /* GL_EXT_texture_lod_bias */
739
      if (!ctx->Extensions.EXT_texture_lod_bias) {
740
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
741
         return;
742
      }
743
      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
744
         *params = texUnit->LodBias;
745
      }
746
      else {
747
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
748
         return;
749
      }
750
   }
751
   else if (target == GL_POINT_SPRITE_NV) {
752
      /* GL_NV_point_sprite */
753
      if (!ctx->Extensions.NV_point_sprite) {
754
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
755
         return;
756
      }
757
      if (pname == GL_COORD_REPLACE_NV) {
758
         *params = (GLfloat) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
759
      }
760
      else {
761
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
762
         return;
763
      }
764
   }
765
   else {
766
      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
767
      return;
768
   }
769
}
770
 
771
 
772
void
773
_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
774
{
775
   GET_CURRENT_CONTEXT(ctx);
776
   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
777
   ASSERT_OUTSIDE_BEGIN_END(ctx);
778
 
779
   if (target == GL_TEXTURE_ENV) {
780
      switch (pname) {
781
         case GL_TEXTURE_ENV_MODE:
782
            *params = (GLint) texUnit->EnvMode;
783
            break;
784
         case GL_TEXTURE_ENV_COLOR:
785
            params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
786
            params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
787
            params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
788
            params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
789
            break;
790
         case GL_COMBINE_RGB_EXT:
791
            if (ctx->Extensions.EXT_texture_env_combine ||
792
                ctx->Extensions.ARB_texture_env_combine) {
793
               *params = (GLint) texUnit->CombineModeRGB;
794
            }
795
            else {
796
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
797
            }
798
            break;
799
         case GL_COMBINE_ALPHA_EXT:
800
            if (ctx->Extensions.EXT_texture_env_combine ||
801
                ctx->Extensions.ARB_texture_env_combine) {
802
               *params = (GLint) texUnit->CombineModeA;
803
            }
804
            else {
805
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
806
            }
807
            break;
808
         case GL_SOURCE0_RGB_EXT:
809
            if (ctx->Extensions.EXT_texture_env_combine ||
810
                ctx->Extensions.ARB_texture_env_combine) {
811
               *params = (GLint) texUnit->CombineSourceRGB[0];
812
            }
813
            else {
814
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
815
            }
816
            break;
817
         case GL_SOURCE1_RGB_EXT:
818
            if (ctx->Extensions.EXT_texture_env_combine ||
819
                ctx->Extensions.ARB_texture_env_combine) {
820
               *params = (GLint) texUnit->CombineSourceRGB[1];
821
            }
822
            else {
823
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
824
            }
825
            break;
826
         case GL_SOURCE2_RGB_EXT:
827
            if (ctx->Extensions.EXT_texture_env_combine ||
828
                ctx->Extensions.ARB_texture_env_combine) {
829
               *params = (GLint) texUnit->CombineSourceRGB[2];
830
            }
831
            else {
832
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
833
            }
834
            break;
835
         case GL_SOURCE0_ALPHA_EXT:
836
            if (ctx->Extensions.EXT_texture_env_combine ||
837
                ctx->Extensions.ARB_texture_env_combine) {
838
               *params = (GLint) texUnit->CombineSourceA[0];
839
            }
840
            else {
841
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
842
            }
843
            break;
844
         case GL_SOURCE1_ALPHA_EXT:
845
            if (ctx->Extensions.EXT_texture_env_combine ||
846
                ctx->Extensions.ARB_texture_env_combine) {
847
               *params = (GLint) texUnit->CombineSourceA[1];
848
            }
849
            else {
850
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
851
            }
852
            break;
853
         case GL_SOURCE2_ALPHA_EXT:
854
            if (ctx->Extensions.EXT_texture_env_combine ||
855
                ctx->Extensions.ARB_texture_env_combine) {
856
               *params = (GLint) texUnit->CombineSourceA[2];
857
            }
858
            else {
859
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
860
            }
861
            break;
862
         case GL_OPERAND0_RGB_EXT:
863
            if (ctx->Extensions.EXT_texture_env_combine ||
864
                ctx->Extensions.ARB_texture_env_combine) {
865
               *params = (GLint) texUnit->CombineOperandRGB[0];
866
            }
867
            else {
868
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
869
            }
870
            break;
871
         case GL_OPERAND1_RGB_EXT:
872
            if (ctx->Extensions.EXT_texture_env_combine ||
873
                ctx->Extensions.ARB_texture_env_combine) {
874
               *params = (GLint) texUnit->CombineOperandRGB[1];
875
            }
876
            else {
877
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
878
            }
879
            break;
880
         case GL_OPERAND2_RGB_EXT:
881
            if (ctx->Extensions.EXT_texture_env_combine ||
882
                ctx->Extensions.ARB_texture_env_combine) {
883
               *params = (GLint) texUnit->CombineOperandRGB[2];
884
            }
885
            else {
886
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
887
            }
888
            break;
889
         case GL_OPERAND0_ALPHA_EXT:
890
            if (ctx->Extensions.EXT_texture_env_combine ||
891
                ctx->Extensions.ARB_texture_env_combine) {
892
               *params = (GLint) texUnit->CombineOperandA[0];
893
            }
894
            else {
895
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
896
            }
897
            break;
898
         case GL_OPERAND1_ALPHA_EXT:
899
            if (ctx->Extensions.EXT_texture_env_combine ||
900
                ctx->Extensions.ARB_texture_env_combine) {
901
               *params = (GLint) texUnit->CombineOperandA[1];
902
            }
903
            else {
904
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
905
            }
906
            break;
907
         case GL_OPERAND2_ALPHA_EXT:
908
            if (ctx->Extensions.EXT_texture_env_combine ||
909
                ctx->Extensions.ARB_texture_env_combine) {
910
               *params = (GLint) texUnit->CombineOperandA[2];
911
            }
912
            else {
913
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
914
            }
915
            break;
916
         case GL_RGB_SCALE_EXT:
917
            if (ctx->Extensions.EXT_texture_env_combine ||
918
                ctx->Extensions.ARB_texture_env_combine) {
919
               if (texUnit->CombineScaleShiftRGB == 0)
920
                  *params = 1;
921
               else if (texUnit->CombineScaleShiftRGB == 1)
922
                  *params = 2;
923
               else
924
                  *params = 4;
925
            }
926
            else {
927
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
928
               return;
929
            }
930
            break;
931
         case GL_ALPHA_SCALE:
932
            if (ctx->Extensions.EXT_texture_env_combine ||
933
                ctx->Extensions.ARB_texture_env_combine) {
934
               if (texUnit->CombineScaleShiftA == 0)
935
                  *params = 1;
936
               else if (texUnit->CombineScaleShiftA == 1)
937
                  *params = 2;
938
               else
939
                  *params = 4;
940
            }
941
            else {
942
               _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)");
943
               return;
944
            }
945
            break;
946
         default:
947
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
948
      }
949
   }
950
   else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
951
      /* GL_EXT_texture_lod_bias */
952
      if (!ctx->Extensions.EXT_texture_lod_bias) {
953
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
954
         return;
955
      }
956
      if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
957
         *params = (GLint) texUnit->LodBias;
958
      }
959
      else {
960
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
961
         return;
962
      }
963
   }
964
   else if (target == GL_POINT_SPRITE_NV) {
965
      /* GL_NV_point_sprite */
966
      if (!ctx->Extensions.NV_point_sprite) {
967
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
968
         return;
969
      }
970
      if (pname == GL_COORD_REPLACE_NV) {
971
         *params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
972
      }
973
      else {
974
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
975
         return;
976
      }
977
   }
978
   else {
979
      _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
980
      return;
981
   }
982
}
983
 
984
 
985
 
986
 
987
/**********************************************************************/
988
/*                       Texture Parameters                           */
989
/**********************************************************************/
990
 
991
 
992
void
993
_mesa_TexParameterf( GLenum target, GLenum pname, GLfloat param )
994
{
995
   _mesa_TexParameterfv(target, pname, &param);
996
}
997
 
998
 
999
void
1000
_mesa_TexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
1001
{
1002
   GET_CURRENT_CONTEXT(ctx);
1003
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1004
   GLenum eparam = (GLenum) (GLint) params[0];
1005
   struct gl_texture_object *texObj;
1006
   ASSERT_OUTSIDE_BEGIN_END(ctx);
1007
 
1008
   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
1009
      _mesa_debug(ctx, "texPARAM %s %s %d...\n",
1010
                  _mesa_lookup_enum_by_nr(target),
1011
                  _mesa_lookup_enum_by_nr(pname),
1012
                  eparam);
1013
 
1014
 
1015
   switch (target) {
1016
      case GL_TEXTURE_1D:
1017
         texObj = texUnit->Current1D;
1018
         break;
1019
      case GL_TEXTURE_2D:
1020
         texObj = texUnit->Current2D;
1021
         break;
1022
      case GL_TEXTURE_3D_EXT:
1023
         texObj = texUnit->Current3D;
1024
         break;
1025
      case GL_TEXTURE_CUBE_MAP_ARB:
1026
         if (!ctx->Extensions.ARB_texture_cube_map) {
1027
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
1028
            return;
1029
         }
1030
         texObj = texUnit->CurrentCubeMap;
1031
         break;
1032
      case GL_TEXTURE_RECTANGLE_NV:
1033
         if (!ctx->Extensions.NV_texture_rectangle) {
1034
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
1035
            return;
1036
         }
1037
         texObj = texUnit->CurrentRect;
1038
         break;
1039
      default:
1040
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexParameter(target)" );
1041
         return;
1042
   }
1043
 
1044
   switch (pname) {
1045
      case GL_TEXTURE_MIN_FILTER:
1046
         /* A small optimization */
1047
         if (texObj->MinFilter == eparam)
1048
            return;
1049
         if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
1050
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1051
            texObj->MinFilter = eparam;
1052
         }
1053
         else if ((eparam==GL_NEAREST_MIPMAP_NEAREST ||
1054
                   eparam==GL_LINEAR_MIPMAP_NEAREST ||
1055
                   eparam==GL_NEAREST_MIPMAP_LINEAR ||
1056
                   eparam==GL_LINEAR_MIPMAP_LINEAR) &&
1057
                  texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
1058
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1059
            texObj->MinFilter = eparam;
1060
         }
1061
         else {
1062
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1063
            return;
1064
         }
1065
         break;
1066
      case GL_TEXTURE_MAG_FILTER:
1067
         /* A small optimization */
1068
         if (texObj->MagFilter == eparam)
1069
            return;
1070
 
1071
         if (eparam==GL_NEAREST || eparam==GL_LINEAR) {
1072
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1073
            texObj->MagFilter = eparam;
1074
         }
1075
         else {
1076
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1077
            return;
1078
         }
1079
         break;
1080
      case GL_TEXTURE_WRAP_S:
1081
         if (texObj->WrapS == eparam)
1082
            return;
1083
         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
1084
             (eparam == GL_CLAMP_TO_BORDER_ARB &&
1085
              ctx->Extensions.ARB_texture_border_clamp)) {
1086
            /* any texture target */
1087
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1088
            texObj->WrapS = eparam;
1089
         }
1090
         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
1091
                  (eparam == GL_REPEAT ||
1092
                   (eparam == GL_MIRRORED_REPEAT_ARB &&
1093
                    ctx->Extensions.ARB_texture_mirrored_repeat) ||
1094
                   (eparam == GL_MIRROR_CLAMP_ATI &&
1095
                    ctx->Extensions.ATI_texture_mirror_once) ||
1096
                   (eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
1097
                    ctx->Extensions.ATI_texture_mirror_once))) {
1098
            /* non-rectangle texture */
1099
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1100
            texObj->WrapS = eparam;
1101
         }
1102
         else {
1103
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1104
            return;
1105
         }
1106
         break;
1107
      case GL_TEXTURE_WRAP_T:
1108
         if (texObj->WrapT == eparam)
1109
            return;
1110
         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
1111
             (eparam == GL_CLAMP_TO_BORDER_ARB &&
1112
              ctx->Extensions.ARB_texture_border_clamp)) {
1113
            /* any texture target */
1114
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1115
            texObj->WrapT = eparam;
1116
         }
1117
         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
1118
                  (eparam == GL_REPEAT ||
1119
                   (eparam == GL_MIRRORED_REPEAT_ARB &&
1120
                    ctx->Extensions.ARB_texture_mirrored_repeat) ||
1121
                   (eparam == GL_MIRROR_CLAMP_ATI &&
1122
                    ctx->Extensions.ATI_texture_mirror_once) ||
1123
                   (eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
1124
                    ctx->Extensions.ATI_texture_mirror_once))) {
1125
            /* non-rectangle texture */
1126
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1127
            texObj->WrapT = eparam;
1128
         }
1129
         else {
1130
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1131
            return;
1132
         }
1133
         break;
1134
      case GL_TEXTURE_WRAP_R_EXT:
1135
         if (texObj->WrapR == eparam)
1136
            return;
1137
         if (eparam == GL_CLAMP || eparam == GL_CLAMP_TO_EDGE ||
1138
             (eparam == GL_CLAMP_TO_BORDER_ARB &&
1139
              ctx->Extensions.ARB_texture_border_clamp)) {
1140
            /* any texture target */
1141
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1142
            texObj->WrapR = eparam;
1143
         }
1144
         else if (texObj->Target != GL_TEXTURE_RECTANGLE_NV &&
1145
                  (eparam == GL_REPEAT ||
1146
                   (eparam == GL_MIRRORED_REPEAT_ARB &&
1147
                    ctx->Extensions.ARB_texture_mirrored_repeat) ||
1148
                   (eparam == GL_MIRROR_CLAMP_ATI &&
1149
                    ctx->Extensions.ATI_texture_mirror_once) ||
1150
                   (eparam == GL_MIRROR_CLAMP_TO_EDGE_ATI &&
1151
                    ctx->Extensions.ATI_texture_mirror_once))) {
1152
            /* non-rectangle texture */
1153
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1154
            texObj->WrapR = eparam;
1155
         }
1156
         else {
1157
            _mesa_error( ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1158
         }
1159
         break;
1160
      case GL_TEXTURE_BORDER_COLOR:
1161
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1162
         texObj->BorderColor[RCOMP] = params[0];
1163
         texObj->BorderColor[GCOMP] = params[1];
1164
         texObj->BorderColor[BCOMP] = params[2];
1165
         texObj->BorderColor[ACOMP] = params[3];
1166
         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[RCOMP], params[0]);
1167
         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[GCOMP], params[1]);
1168
         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[BCOMP], params[2]);
1169
         UNCLAMPED_FLOAT_TO_CHAN(texObj->_BorderChan[ACOMP], params[3]);
1170
         break;
1171
      case GL_TEXTURE_MIN_LOD:
1172
         if (texObj->MinLod == params[0])
1173
            return;
1174
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1175
         texObj->MinLod = params[0];
1176
         break;
1177
      case GL_TEXTURE_MAX_LOD:
1178
         if (texObj->MaxLod == params[0])
1179
            return;
1180
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1181
         texObj->MaxLod = params[0];
1182
         break;
1183
      case GL_TEXTURE_BASE_LEVEL:
1184
         if (params[0] < 0.0) {
1185
            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1186
            return;
1187
         }
1188
         if (target == GL_TEXTURE_RECTANGLE_NV && params[0] != 0.0) {
1189
            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1190
            return;
1191
         }
1192
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1193
         texObj->BaseLevel = (GLint) params[0];
1194
         break;
1195
      case GL_TEXTURE_MAX_LEVEL:
1196
         if (params[0] < 0.0) {
1197
            _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1198
            return;
1199
         }
1200
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1201
         texObj->MaxLevel = (GLint) params[0];
1202
         break;
1203
      case GL_TEXTURE_PRIORITY:
1204
         FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1205
         texObj->Priority = CLAMP( params[0], 0.0F, 1.0F );
1206
         break;
1207
      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1208
         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1209
            if (params[0] < 1.0) {
1210
               _mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
1211
               return;
1212
            }
1213
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1214
            texObj->MaxAnisotropy = params[0];
1215
         }
1216
         else {
1217
            _mesa_error(ctx, GL_INVALID_ENUM,
1218
                        "glTexParameter(pname=GL_TEXTURE_MAX_ANISOTROPY_EXT)");
1219
            return;
1220
         }
1221
         break;
1222
      case GL_TEXTURE_COMPARE_SGIX:
1223
         if (ctx->Extensions.SGIX_shadow) {
1224
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1225
            texObj->CompareFlag = params[0] ? GL_TRUE : GL_FALSE;
1226
         }
1227
         else {
1228
            _mesa_error(ctx, GL_INVALID_ENUM,
1229
                        "glTexParameter(pname=GL_TEXTURE_COMPARE_SGIX)");
1230
            return;
1231
         }
1232
         break;
1233
      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1234
         if (ctx->Extensions.SGIX_shadow) {
1235
            GLenum op = (GLenum) params[0];
1236
            if (op == GL_TEXTURE_LEQUAL_R_SGIX ||
1237
                op == GL_TEXTURE_GEQUAL_R_SGIX) {
1238
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1239
               texObj->CompareOperator = op;
1240
            }
1241
            else {
1242
               _mesa_error(ctx, GL_INVALID_ENUM, "glTexParameter(param)");
1243
            }
1244
         }
1245
         else {
1246
            _mesa_error(ctx, GL_INVALID_ENUM,
1247
                    "glTexParameter(pname=GL_TEXTURE_COMPARE_OPERATOR_SGIX)");
1248
            return;
1249
         }
1250
         break;
1251
      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
1252
         if (ctx->Extensions.SGIX_shadow_ambient) {
1253
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1254
            texObj->ShadowAmbient = CLAMP(params[0], 0.0F, 1.0F);
1255
         }
1256
         else {
1257
            _mesa_error(ctx, GL_INVALID_ENUM,
1258
                        "glTexParameter(pname=GL_SHADOW_AMBIENT_SGIX)");
1259
            return;
1260
         }
1261
         break;
1262
      case GL_GENERATE_MIPMAP_SGIS:
1263
         if (ctx->Extensions.SGIS_generate_mipmap) {
1264
            texObj->GenerateMipmap = params[0] ? GL_TRUE : GL_FALSE;
1265
         }
1266
         else {
1267
            _mesa_error(ctx, GL_INVALID_ENUM,
1268
                        "glTexParameter(pname=GL_GENERATE_MIPMAP_SGIS)");
1269
            return;
1270
         }
1271
         break;
1272
      case GL_TEXTURE_COMPARE_MODE_ARB:
1273
         if (ctx->Extensions.ARB_shadow) {
1274
            const GLenum mode = (GLenum) params[0];
1275
            if (mode == GL_NONE || mode == GL_COMPARE_R_TO_TEXTURE_ARB) {
1276
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1277
               texObj->CompareMode = mode;
1278
            }
1279
            else {
1280
               _mesa_error(ctx, GL_INVALID_ENUM,
1281
                           "glTexParameter(bad GL_TEXTURE_COMPARE_MODE_ARB)");
1282
               return;
1283
            }
1284
         }
1285
         else {
1286
            _mesa_error(ctx, GL_INVALID_ENUM,
1287
                        "glTexParameter(pname=GL_TEXTURE_COMPARE_MODE_ARB)");
1288
            return;
1289
         }
1290
         break;
1291
      case GL_TEXTURE_COMPARE_FUNC_ARB:
1292
         if (ctx->Extensions.ARB_shadow) {
1293
            const GLenum func = (GLenum) params[0];
1294
            if (func == GL_LEQUAL || func == GL_GEQUAL) {
1295
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1296
               texObj->CompareFunc = func;
1297
            }
1298
            else if (ctx->Extensions.EXT_shadow_funcs &&
1299
                     (func == GL_EQUAL ||
1300
                      func == GL_NOTEQUAL ||
1301
                      func == GL_LESS ||
1302
                      func == GL_GREATER ||
1303
                      func == GL_ALWAYS ||
1304
                      func == GL_NEVER)) {
1305
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1306
               texObj->CompareFunc = func;
1307
            }
1308
            else {
1309
               _mesa_error(ctx, GL_INVALID_ENUM,
1310
                           "glTexParameter(bad GL_TEXTURE_COMPARE_FUNC_ARB)");
1311
               return;
1312
            }
1313
         }
1314
         else {
1315
            _mesa_error(ctx, GL_INVALID_ENUM,
1316
                        "glTexParameter(pname=GL_TEXTURE_COMPARE_FUNC_ARB)");
1317
            return;
1318
         }
1319
         break;
1320
      case GL_DEPTH_TEXTURE_MODE_ARB:
1321
         if (ctx->Extensions.ARB_depth_texture) {
1322
            const GLenum result = (GLenum) params[0];
1323
            if (result == GL_LUMINANCE || result == GL_INTENSITY
1324
                || result == GL_ALPHA) {
1325
               FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1326
               texObj->DepthMode = result;
1327
            }
1328
            else {
1329
               _mesa_error(ctx, GL_INVALID_ENUM,
1330
                          "glTexParameter(bad GL_DEPTH_TEXTURE_MODE_ARB)");
1331
               return;
1332
            }
1333
         }
1334
         else {
1335
            _mesa_error(ctx, GL_INVALID_ENUM,
1336
                        "glTexParameter(pname=GL_DEPTH_TEXTURE_MODE_ARB)");
1337
            return;
1338
         }
1339
         break;
1340
 
1341
      default:
1342
         _mesa_error(ctx, GL_INVALID_ENUM,
1343
                     "glTexParameter(pname=0x%x)", pname);
1344
         return;
1345
   }
1346
 
1347
   texObj->Complete = GL_FALSE;
1348
 
1349
   if (ctx->Driver.TexParameter) {
1350
      (*ctx->Driver.TexParameter)( ctx, target, texObj, pname, params );
1351
   }
1352
}
1353
 
1354
 
1355
void
1356
_mesa_TexParameteri( GLenum target, GLenum pname, GLint param )
1357
{
1358
   GLfloat fparam[4];
1359
   fparam[0] = (GLfloat) param;
1360
   fparam[1] = fparam[2] = fparam[3] = 0.0;
1361
   _mesa_TexParameterfv(target, pname, fparam);
1362
}
1363
 
1364
 
1365
void
1366
_mesa_TexParameteriv( GLenum target, GLenum pname, const GLint *params )
1367
{
1368
   GLfloat fparam[4];
1369
   if (pname == GL_TEXTURE_BORDER_COLOR) {
1370
      fparam[0] = INT_TO_FLOAT(params[0]);
1371
      fparam[1] = INT_TO_FLOAT(params[1]);
1372
      fparam[2] = INT_TO_FLOAT(params[2]);
1373
      fparam[3] = INT_TO_FLOAT(params[3]);
1374
   }
1375
   else {
1376
      fparam[0] = (GLfloat) params[0];
1377
      fparam[1] = fparam[2] = fparam[3] = 0.0F;
1378
   }
1379
   _mesa_TexParameterfv(target, pname, fparam);
1380
}
1381
 
1382
 
1383
void
1384
_mesa_GetTexLevelParameterfv( GLenum target, GLint level,
1385
                              GLenum pname, GLfloat *params )
1386
{
1387
   GLint iparam;
1388
   _mesa_GetTexLevelParameteriv( target, level, pname, &iparam );
1389
   *params = (GLfloat) iparam;
1390
}
1391
 
1392
 
1393
static GLuint
1394
tex_image_dimensions(GLcontext *ctx, GLenum target)
1395
{
1396
   switch (target) {
1397
      case GL_TEXTURE_1D:
1398
      case GL_PROXY_TEXTURE_1D:
1399
         return 1;
1400
      case GL_TEXTURE_2D:
1401
      case GL_PROXY_TEXTURE_2D:
1402
         return 2;
1403
      case GL_TEXTURE_3D:
1404
      case GL_PROXY_TEXTURE_3D:
1405
         return 3;
1406
      case GL_TEXTURE_CUBE_MAP_ARB:
1407
      case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
1408
      case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
1409
      case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
1410
      case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
1411
      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
1412
      case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
1413
      case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
1414
         return ctx->Extensions.ARB_texture_cube_map ? 2 : 0;
1415
      case GL_TEXTURE_RECTANGLE_NV:
1416
      case GL_PROXY_TEXTURE_RECTANGLE_NV:
1417
         return ctx->Extensions.NV_texture_rectangle ? 2 : 0;
1418
      default:
1419
         _mesa_problem(ctx, "bad target in _mesa_tex_target_dimensions()");
1420
         return 0;
1421
   }
1422
}
1423
 
1424
 
1425
void
1426
_mesa_GetTexLevelParameteriv( GLenum target, GLint level,
1427
                              GLenum pname, GLint *params )
1428
{
1429
   GET_CURRENT_CONTEXT(ctx);
1430
   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1431
   const struct gl_texture_image *img = NULL;
1432
   GLuint dimensions;
1433
   GLboolean isProxy;
1434
   GLint maxLevels;
1435
   ASSERT_OUTSIDE_BEGIN_END(ctx);
1436
 
1437
   /* this will catch bad target values */
1438
   dimensions = tex_image_dimensions(ctx, target);  /* 1, 2 or 3 */
1439
   if (dimensions == 0) {
1440
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexLevelParameter[if]v(target)");
1441
      return;
1442
   }
1443
 
1444
   switch (target) {
1445
   case GL_TEXTURE_1D:
1446
   case GL_PROXY_TEXTURE_1D:
1447
   case GL_TEXTURE_2D:
1448
   case GL_PROXY_TEXTURE_2D:
1449
      maxLevels = ctx->Const.MaxTextureLevels;
1450
      break;
1451
   case GL_TEXTURE_3D:
1452
   case GL_PROXY_TEXTURE_3D:
1453
      maxLevels = ctx->Const.Max3DTextureLevels;
1454
      break;
1455
   case GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB:
1456
   case GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB:
1457
   case GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB:
1458
   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB:
1459
   case GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB:
1460
   case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB:
1461
   case GL_PROXY_TEXTURE_CUBE_MAP_ARB:
1462
      maxLevels = ctx->Const.MaxCubeTextureLevels;
1463
      break;
1464
   case GL_TEXTURE_RECTANGLE_NV:
1465
   case GL_PROXY_TEXTURE_RECTANGLE_NV:
1466
      maxLevels = 1;
1467
      break;
1468
   default:
1469
      _mesa_problem(ctx, "switch in _mesa_GetTexLevelParameter");
1470
      return;
1471
   }
1472
 
1473
   if (level < 0 || level >= maxLevels) {
1474
      _mesa_error( ctx, GL_INVALID_VALUE, "glGetTexLevelParameter[if]v" );
1475
      return;
1476
   }
1477
 
1478
   img = _mesa_select_tex_image(ctx, texUnit, target, level);
1479
   if (!img || !img->TexFormat) {
1480
      /* undefined texture image */
1481
      if (pname == GL_TEXTURE_COMPONENTS)
1482
         *params = 1;
1483
      else
1484
         *params = 0;
1485
      return;
1486
   }
1487
 
1488
   isProxy = (target == GL_PROXY_TEXTURE_1D) ||
1489
             (target == GL_PROXY_TEXTURE_2D) ||
1490
             (target == GL_PROXY_TEXTURE_3D) ||
1491
             (target == GL_PROXY_TEXTURE_CUBE_MAP_ARB) ||
1492
             (target == GL_PROXY_TEXTURE_RECTANGLE_NV);
1493
 
1494
   switch (pname) {
1495
      case GL_TEXTURE_WIDTH:
1496
         *params = img->Width;
1497
         return;
1498
      case GL_TEXTURE_HEIGHT:
1499
         *params = img->Height;
1500
         return;
1501
      case GL_TEXTURE_DEPTH:
1502
         *params = img->Depth;
1503
         return;
1504
      case GL_TEXTURE_INTERNAL_FORMAT:
1505
         *params = img->IntFormat;
1506
         return;
1507
      case GL_TEXTURE_BORDER:
1508
         *params = img->Border;
1509
         return;
1510
      case GL_TEXTURE_RED_SIZE:
1511
         if (img->Format == GL_RGB || img->Format == GL_RGBA)
1512
            *params = img->TexFormat->RedBits;
1513
         else
1514
            *params = 0;
1515
         return;
1516
      case GL_TEXTURE_GREEN_SIZE:
1517
         if (img->Format == GL_RGB || img->Format == GL_RGBA)
1518
            *params = img->TexFormat->GreenBits;
1519
         else
1520
            *params = 0;
1521
         return;
1522
      case GL_TEXTURE_BLUE_SIZE:
1523
         if (img->Format == GL_RGB || img->Format == GL_RGBA)
1524
            *params = img->TexFormat->BlueBits;
1525
         else
1526
            *params = 0;
1527
         return;
1528
      case GL_TEXTURE_ALPHA_SIZE:
1529
         if (img->Format == GL_ALPHA || img->Format == GL_LUMINANCE_ALPHA ||
1530
             img->Format == GL_RGBA)
1531
            *params = img->TexFormat->AlphaBits;
1532
         else
1533
            *params = 0;
1534
         return;
1535
      case GL_TEXTURE_INTENSITY_SIZE:
1536
         if (img->Format != GL_INTENSITY)
1537
            *params = 0;
1538
         else if (img->TexFormat->IntensityBits > 0)
1539
            *params = img->TexFormat->IntensityBits;
1540
         else /* intensity probably stored as rgb texture */
1541
            *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1542
         return;
1543
      case GL_TEXTURE_LUMINANCE_SIZE:
1544
         if (img->Format != GL_LUMINANCE &&
1545
             img->Format != GL_LUMINANCE_ALPHA)
1546
            *params = 0;
1547
         else if (img->TexFormat->LuminanceBits > 0)
1548
            *params = img->TexFormat->LuminanceBits;
1549
         else /* luminance probably stored as rgb texture */
1550
            *params = MIN2(img->TexFormat->RedBits, img->TexFormat->GreenBits);
1551
         return;
1552
      case GL_TEXTURE_INDEX_SIZE_EXT:
1553
         if (img->Format == GL_COLOR_INDEX)
1554
            *params = img->TexFormat->IndexBits;
1555
         else
1556
            *params = 0;
1557
         return;
1558
      case GL_DEPTH_BITS:
1559
         /* XXX this isn't in the GL_SGIX_depth_texture spec
1560
          * but seems appropriate.
1561
          */
1562
         if (ctx->Extensions.SGIX_depth_texture)
1563
            *params = img->TexFormat->DepthBits;
1564
         else
1565
            _mesa_error(ctx, GL_INVALID_ENUM,
1566
                        "glGetTexLevelParameter[if]v(pname)");
1567
         return;
1568
 
1569
      /* GL_ARB_texture_compression */
1570
      case GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB:
1571
         if (ctx->Extensions.ARB_texture_compression) {
1572
            if (img->IsCompressed && !isProxy)
1573
               *params = img->CompressedSize;
1574
            else
1575
               _mesa_error(ctx, GL_INVALID_OPERATION,
1576
                           "glGetTexLevelParameter[if]v(pname)");
1577
         }
1578
         else {
1579
            _mesa_error(ctx, GL_INVALID_ENUM,
1580
                        "glGetTexLevelParameter[if]v(pname)");
1581
         }
1582
         return;
1583
      case GL_TEXTURE_COMPRESSED_ARB:
1584
         if (ctx->Extensions.ARB_texture_compression) {
1585
            *params = (GLint) img->IsCompressed;
1586
         }
1587
         else {
1588
            _mesa_error(ctx, GL_INVALID_ENUM,
1589
                        "glGetTexLevelParameter[if]v(pname)");
1590
         }
1591
         return;
1592
 
1593
      default:
1594
         _mesa_error(ctx, GL_INVALID_ENUM,
1595
                     "glGetTexLevelParameter[if]v(pname)");
1596
   }
1597
}
1598
 
1599
 
1600
 
1601
void
1602
_mesa_GetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
1603
{
1604
   GET_CURRENT_CONTEXT(ctx);
1605
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1606
   struct gl_texture_object *obj;
1607
   ASSERT_OUTSIDE_BEGIN_END(ctx);
1608
 
1609
   obj = _mesa_select_tex_object(ctx, texUnit, target);
1610
   if (!obj) {
1611
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameterfv(target)");
1612
      return;
1613
   }
1614
 
1615
   switch (pname) {
1616
      case GL_TEXTURE_MAG_FILTER:
1617
         *params = ENUM_TO_FLOAT(obj->MagFilter);
1618
         return;
1619
      case GL_TEXTURE_MIN_FILTER:
1620
         *params = ENUM_TO_FLOAT(obj->MinFilter);
1621
         return;
1622
      case GL_TEXTURE_WRAP_S:
1623
         *params = ENUM_TO_FLOAT(obj->WrapS);
1624
         return;
1625
      case GL_TEXTURE_WRAP_T:
1626
         *params = ENUM_TO_FLOAT(obj->WrapT);
1627
         return;
1628
      case GL_TEXTURE_WRAP_R_EXT:
1629
         *params = ENUM_TO_FLOAT(obj->WrapR);
1630
         return;
1631
      case GL_TEXTURE_BORDER_COLOR:
1632
         params[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
1633
         params[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
1634
         params[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
1635
         params[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
1636
         return;
1637
      case GL_TEXTURE_RESIDENT:
1638
         {
1639
            GLboolean resident;
1640
            if (ctx->Driver.IsTextureResident)
1641
               resident = ctx->Driver.IsTextureResident(ctx, obj);
1642
            else
1643
               resident = GL_TRUE;
1644
            *params = ENUM_TO_FLOAT(resident);
1645
         }
1646
         return;
1647
      case GL_TEXTURE_PRIORITY:
1648
         *params = obj->Priority;
1649
         return;
1650
      case GL_TEXTURE_MIN_LOD:
1651
         *params = obj->MinLod;
1652
         return;
1653
      case GL_TEXTURE_MAX_LOD:
1654
         *params = obj->MaxLod;
1655
         return;
1656
      case GL_TEXTURE_BASE_LEVEL:
1657
         *params = (GLfloat) obj->BaseLevel;
1658
         return;
1659
      case GL_TEXTURE_MAX_LEVEL:
1660
         *params = (GLfloat) obj->MaxLevel;
1661
         return;
1662
      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1663
         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1664
            *params = obj->MaxAnisotropy;
1665
            return;
1666
         }
1667
         break;
1668
      case GL_TEXTURE_COMPARE_SGIX:
1669
         if (ctx->Extensions.SGIX_shadow) {
1670
            *params = (GLfloat) obj->CompareFlag;
1671
            return;
1672
         }
1673
         break;
1674
      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1675
         if (ctx->Extensions.SGIX_shadow) {
1676
            *params = (GLfloat) obj->CompareOperator;
1677
            return;
1678
         }
1679
         break;
1680
      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
1681
         if (ctx->Extensions.SGIX_shadow_ambient) {
1682
            *params = obj->ShadowAmbient;
1683
            return;
1684
         }
1685
         break;
1686
      case GL_GENERATE_MIPMAP_SGIS:
1687
         if (ctx->Extensions.SGIS_generate_mipmap) {
1688
            *params = (GLfloat) obj->GenerateMipmap;
1689
            return;
1690
         }
1691
         break;
1692
      case GL_TEXTURE_COMPARE_MODE_ARB:
1693
         if (ctx->Extensions.ARB_shadow) {
1694
            *params = (GLfloat) obj->CompareMode;
1695
            return;
1696
         }
1697
         break;
1698
      case GL_TEXTURE_COMPARE_FUNC_ARB:
1699
         if (ctx->Extensions.ARB_shadow) {
1700
            *params = (GLfloat) obj->CompareFunc;
1701
            return;
1702
         }
1703
         break;
1704
      case GL_DEPTH_TEXTURE_MODE_ARB:
1705
         if (ctx->Extensions.ARB_depth_texture) {
1706
            *params = (GLfloat) obj->DepthMode;
1707
            return;
1708
         }
1709
         break;
1710
      default:
1711
         ; /* silence warnings */
1712
   }
1713
   /* If we get here, pname was an unrecognized enum */
1714
   _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameterfv(pname)" );
1715
}
1716
 
1717
 
1718
void
1719
_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
1720
{
1721
   GET_CURRENT_CONTEXT(ctx);
1722
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
1723
   struct gl_texture_object *obj;
1724
   ASSERT_OUTSIDE_BEGIN_END(ctx);
1725
 
1726
   obj = _mesa_select_tex_object(ctx, texUnit, target);
1727
   if (!obj) {
1728
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
1729
      return;
1730
   }
1731
 
1732
   switch (pname) {
1733
      case GL_TEXTURE_MAG_FILTER:
1734
         *params = (GLint) obj->MagFilter;
1735
         return;
1736
      case GL_TEXTURE_MIN_FILTER:
1737
         *params = (GLint) obj->MinFilter;
1738
         return;
1739
      case GL_TEXTURE_WRAP_S:
1740
         *params = (GLint) obj->WrapS;
1741
         return;
1742
      case GL_TEXTURE_WRAP_T:
1743
         *params = (GLint) obj->WrapT;
1744
         return;
1745
      case GL_TEXTURE_WRAP_R_EXT:
1746
         *params = (GLint) obj->WrapR;
1747
         return;
1748
      case GL_TEXTURE_BORDER_COLOR:
1749
         {
1750
            GLfloat b[4];
1751
            b[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
1752
            b[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
1753
            b[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
1754
            b[3] = CLAMP(obj->BorderColor[3], 0.0F, 1.0F);
1755
            params[0] = FLOAT_TO_INT(b[0]);
1756
            params[1] = FLOAT_TO_INT(b[1]);
1757
            params[2] = FLOAT_TO_INT(b[2]);
1758
            params[3] = FLOAT_TO_INT(b[3]);
1759
         }
1760
         return;
1761
      case GL_TEXTURE_RESIDENT:
1762
         {
1763
            GLboolean resident;
1764
            if (ctx->Driver.IsTextureResident)
1765
               resident = ctx->Driver.IsTextureResident(ctx, obj);
1766
            else
1767
               resident = GL_TRUE;
1768
            *params = (GLint) resident;
1769
         }
1770
         return;
1771
      case GL_TEXTURE_PRIORITY:
1772
         *params = (GLint) obj->Priority;
1773
         return;
1774
      case GL_TEXTURE_MIN_LOD:
1775
         *params = (GLint) obj->MinLod;
1776
         return;
1777
      case GL_TEXTURE_MAX_LOD:
1778
         *params = (GLint) obj->MaxLod;
1779
         return;
1780
      case GL_TEXTURE_BASE_LEVEL:
1781
         *params = obj->BaseLevel;
1782
         return;
1783
      case GL_TEXTURE_MAX_LEVEL:
1784
         *params = obj->MaxLevel;
1785
         return;
1786
      case GL_TEXTURE_MAX_ANISOTROPY_EXT:
1787
         if (ctx->Extensions.EXT_texture_filter_anisotropic) {
1788
            *params = (GLint) obj->MaxAnisotropy;
1789
            return;
1790
         }
1791
         break;
1792
      case GL_TEXTURE_COMPARE_SGIX:
1793
         if (ctx->Extensions.SGIX_shadow) {
1794
            *params = (GLint) obj->CompareFlag;
1795
            return;
1796
         }
1797
         break;
1798
      case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
1799
         if (ctx->Extensions.SGIX_shadow) {
1800
            *params = (GLint) obj->CompareOperator;
1801
            return;
1802
         }
1803
         break;
1804
      case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
1805
         if (ctx->Extensions.SGIX_shadow_ambient) {
1806
            *params = (GLint) FLOAT_TO_INT(obj->ShadowAmbient);
1807
            return;
1808
         }
1809
         break;
1810
      case GL_GENERATE_MIPMAP_SGIS:
1811
         if (ctx->Extensions.SGIS_generate_mipmap) {
1812
            *params = (GLint) obj->GenerateMipmap;
1813
            return;
1814
         }
1815
         break;
1816
      case GL_TEXTURE_COMPARE_MODE_ARB:
1817
         if (ctx->Extensions.ARB_shadow) {
1818
            *params = (GLint) obj->CompareMode;
1819
            return;
1820
         }
1821
         break;
1822
      case GL_TEXTURE_COMPARE_FUNC_ARB:
1823
         if (ctx->Extensions.ARB_shadow) {
1824
            *params = (GLint) obj->CompareFunc;
1825
            return;
1826
         }
1827
         break;
1828
      case GL_DEPTH_TEXTURE_MODE_ARB:
1829
         if (ctx->Extensions.ARB_depth_texture) {
1830
            *params = (GLint) obj->DepthMode;
1831
            return;
1832
         }
1833
         break;
1834
      default:
1835
         ; /* silence warnings */
1836
   }
1837
   /* If we get here, pname was an unrecognized enum */
1838
   _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
1839
}
1840
 
1841
 
1842
 
1843
 
1844
/**********************************************************************/
1845
/*                    Texture Coord Generation                        */
1846
/**********************************************************************/
1847
 
1848
 
1849
void
1850
_mesa_TexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
1851
{
1852
   GET_CURRENT_CONTEXT(ctx);
1853
   GLuint tUnit = ctx->Texture.CurrentUnit;
1854
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
1855
   ASSERT_OUTSIDE_BEGIN_END(ctx);
1856
 
1857
   if (MESA_VERBOSE&(VERBOSE_API|VERBOSE_TEXTURE))
1858
      _mesa_debug(ctx, "texGEN %s %s %x...\n",
1859
                  _mesa_lookup_enum_by_nr(coord),
1860
                  _mesa_lookup_enum_by_nr(pname),
1861
                  *(int *)params);
1862
 
1863
   switch (coord) {
1864
      case GL_S:
1865
         if (pname==GL_TEXTURE_GEN_MODE) {
1866
            GLenum mode = (GLenum) (GLint) *params;
1867
            GLuint bits;
1868
            switch (mode) {
1869
            case GL_OBJECT_LINEAR:
1870
               bits = TEXGEN_OBJ_LINEAR;
1871
               break;
1872
            case GL_EYE_LINEAR:
1873
               bits = TEXGEN_EYE_LINEAR;
1874
               break;
1875
            case GL_REFLECTION_MAP_NV:
1876
               bits = TEXGEN_REFLECTION_MAP_NV;
1877
               break;
1878
            case GL_NORMAL_MAP_NV:
1879
               bits = TEXGEN_NORMAL_MAP_NV;
1880
               break;
1881
            case GL_SPHERE_MAP:
1882
               bits = TEXGEN_SPHERE_MAP;
1883
               break;
1884
            default:
1885
               _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1886
               return;
1887
            }
1888
            if (texUnit->GenModeS == mode)
1889
               return;
1890
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1891
            texUnit->GenModeS = mode;
1892
            texUnit->_GenBitS = bits;
1893
         }
1894
         else if (pname==GL_OBJECT_PLANE) {
1895
            if (TEST_EQ_4V(texUnit->ObjectPlaneS, params))
1896
                return;
1897
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1898
            texUnit->ObjectPlaneS[0] = params[0];
1899
            texUnit->ObjectPlaneS[1] = params[1];
1900
            texUnit->ObjectPlaneS[2] = params[2];
1901
            texUnit->ObjectPlaneS[3] = params[3];
1902
         }
1903
         else if (pname==GL_EYE_PLANE) {
1904
            GLfloat tmp[4];
1905
 
1906
            /* Transform plane equation by the inverse modelview matrix */
1907
            if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
1908
               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
1909
            }
1910
            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
1911
            if (TEST_EQ_4V(texUnit->EyePlaneS, tmp))
1912
               return;
1913
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1914
            COPY_4FV(texUnit->EyePlaneS, tmp);
1915
         }
1916
         else {
1917
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1918
            return;
1919
         }
1920
         break;
1921
      case GL_T:
1922
         if (pname==GL_TEXTURE_GEN_MODE) {
1923
            GLenum mode = (GLenum) (GLint) *params;
1924
            GLuint bitt;
1925
            switch (mode) {
1926
               case GL_OBJECT_LINEAR:
1927
                  bitt = TEXGEN_OBJ_LINEAR;
1928
                  break;
1929
               case GL_EYE_LINEAR:
1930
                  bitt = TEXGEN_EYE_LINEAR;
1931
                  break;
1932
               case GL_REFLECTION_MAP_NV:
1933
                  bitt = TEXGEN_REFLECTION_MAP_NV;
1934
                  break;
1935
               case GL_NORMAL_MAP_NV:
1936
                  bitt = TEXGEN_NORMAL_MAP_NV;
1937
                  break;
1938
               case GL_SPHERE_MAP:
1939
                  bitt = TEXGEN_SPHERE_MAP;
1940
                  break;
1941
               default:
1942
                  _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1943
                  return;
1944
            }
1945
            if (texUnit->GenModeT == mode)
1946
               return;
1947
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1948
            texUnit->GenModeT = mode;
1949
            texUnit->_GenBitT = bitt;
1950
         }
1951
         else if (pname==GL_OBJECT_PLANE) {
1952
            if (TEST_EQ_4V(texUnit->ObjectPlaneT, params))
1953
                return;
1954
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1955
            texUnit->ObjectPlaneT[0] = params[0];
1956
            texUnit->ObjectPlaneT[1] = params[1];
1957
            texUnit->ObjectPlaneT[2] = params[2];
1958
            texUnit->ObjectPlaneT[3] = params[3];
1959
         }
1960
         else if (pname==GL_EYE_PLANE) {
1961
            GLfloat tmp[4];
1962
            /* Transform plane equation by the inverse modelview matrix */
1963
            if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
1964
               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
1965
            }
1966
            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
1967
            if (TEST_EQ_4V(texUnit->EyePlaneT, tmp))
1968
                return;
1969
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
1970
            COPY_4FV(texUnit->EyePlaneT, tmp);
1971
         }
1972
         else {
1973
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
1974
            return;
1975
         }
1976
         break;
1977
      case GL_R:
1978
         if (pname==GL_TEXTURE_GEN_MODE) {
1979
            GLenum mode = (GLenum) (GLint) *params;
1980
            GLuint bitr;
1981
            switch (mode) {
1982
            case GL_OBJECT_LINEAR:
1983
               bitr = TEXGEN_OBJ_LINEAR;
1984
               break;
1985
            case GL_REFLECTION_MAP_NV:
1986
               bitr = TEXGEN_REFLECTION_MAP_NV;
1987
               break;
1988
            case GL_NORMAL_MAP_NV:
1989
               bitr = TEXGEN_NORMAL_MAP_NV;
1990
               break;
1991
            case GL_EYE_LINEAR:
1992
               bitr = TEXGEN_EYE_LINEAR;
1993
               break;
1994
            default:
1995
               _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
1996
               return;
1997
            }
1998
            if (texUnit->GenModeR == mode)
1999
               return;
2000
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2001
            texUnit->GenModeR = mode;
2002
            texUnit->_GenBitR = bitr;
2003
         }
2004
         else if (pname==GL_OBJECT_PLANE) {
2005
            if (TEST_EQ_4V(texUnit->ObjectPlaneR, params))
2006
                return;
2007
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2008
            texUnit->ObjectPlaneR[0] = params[0];
2009
            texUnit->ObjectPlaneR[1] = params[1];
2010
            texUnit->ObjectPlaneR[2] = params[2];
2011
            texUnit->ObjectPlaneR[3] = params[3];
2012
         }
2013
         else if (pname==GL_EYE_PLANE) {
2014
            GLfloat tmp[4];
2015
            /* Transform plane equation by the inverse modelview matrix */
2016
            if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
2017
               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
2018
            }
2019
            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
2020
            if (TEST_EQ_4V(texUnit->EyePlaneR, tmp))
2021
               return;
2022
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2023
            COPY_4FV(texUnit->EyePlaneR, tmp);
2024
         }
2025
         else {
2026
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
2027
            return;
2028
         }
2029
         break;
2030
      case GL_Q:
2031
         if (pname==GL_TEXTURE_GEN_MODE) {
2032
            GLenum mode = (GLenum) (GLint) *params;
2033
            GLuint bitq;
2034
            switch (mode) {
2035
            case GL_OBJECT_LINEAR:
2036
               bitq = TEXGEN_OBJ_LINEAR;
2037
               break;
2038
            case GL_EYE_LINEAR:
2039
               bitq = TEXGEN_EYE_LINEAR;
2040
               break;
2041
            default:
2042
               _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(param)" );
2043
               return;
2044
            }
2045
            if (texUnit->GenModeQ == mode)
2046
               return;
2047
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2048
            texUnit->GenModeQ = mode;
2049
            texUnit->_GenBitQ = bitq;
2050
         }
2051
         else if (pname==GL_OBJECT_PLANE) {
2052
            if (TEST_EQ_4V(texUnit->ObjectPlaneQ, params))
2053
                return;
2054
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2055
            texUnit->ObjectPlaneQ[0] = params[0];
2056
            texUnit->ObjectPlaneQ[1] = params[1];
2057
            texUnit->ObjectPlaneQ[2] = params[2];
2058
            texUnit->ObjectPlaneQ[3] = params[3];
2059
         }
2060
         else if (pname==GL_EYE_PLANE) {
2061
            GLfloat tmp[4];
2062
            /* Transform plane equation by the inverse modelview matrix */
2063
            if (ctx->ModelviewMatrixStack.Top->flags & MAT_DIRTY_INVERSE) {
2064
               _math_matrix_analyse( ctx->ModelviewMatrixStack.Top );
2065
            }
2066
            _mesa_transform_vector( tmp, params, ctx->ModelviewMatrixStack.Top->inv );
2067
            if (TEST_EQ_4V(texUnit->EyePlaneQ, tmp))
2068
               return;
2069
            FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2070
            COPY_4FV(texUnit->EyePlaneQ, tmp);
2071
         }
2072
         else {
2073
            _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(pname)" );
2074
            return;
2075
         }
2076
         break;
2077
      default:
2078
         _mesa_error( ctx, GL_INVALID_ENUM, "glTexGenfv(coord)" );
2079
         return;
2080
   }
2081
 
2082
   if (ctx->Driver.TexGen)
2083
      ctx->Driver.TexGen( ctx, coord, pname, params );
2084
}
2085
 
2086
 
2087
void
2088
_mesa_TexGeniv(GLenum coord, GLenum pname, const GLint *params )
2089
{
2090
   GLfloat p[4];
2091
   p[0] = (GLfloat) params[0];
2092
   p[1] = (GLfloat) params[1];
2093
   p[2] = (GLfloat) params[2];
2094
   p[3] = (GLfloat) params[3];
2095
   _mesa_TexGenfv(coord, pname, p);
2096
}
2097
 
2098
 
2099
void
2100
_mesa_TexGend(GLenum coord, GLenum pname, GLdouble param )
2101
{
2102
   GLfloat p = (GLfloat) param;
2103
   _mesa_TexGenfv( coord, pname, &p );
2104
}
2105
 
2106
 
2107
void
2108
_mesa_TexGendv(GLenum coord, GLenum pname, const GLdouble *params )
2109
{
2110
   GLfloat p[4];
2111
   p[0] = (GLfloat) params[0];
2112
   p[1] = (GLfloat) params[1];
2113
   p[2] = (GLfloat) params[2];
2114
   p[3] = (GLfloat) params[3];
2115
   _mesa_TexGenfv( coord, pname, p );
2116
}
2117
 
2118
 
2119
void
2120
_mesa_TexGenf( GLenum coord, GLenum pname, GLfloat param )
2121
{
2122
   _mesa_TexGenfv(coord, pname, &param);
2123
}
2124
 
2125
 
2126
void
2127
_mesa_TexGeni( GLenum coord, GLenum pname, GLint param )
2128
{
2129
   _mesa_TexGeniv( coord, pname, &param );
2130
}
2131
 
2132
 
2133
 
2134
void
2135
_mesa_GetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
2136
{
2137
   GET_CURRENT_CONTEXT(ctx);
2138
   GLuint tUnit = ctx->Texture.CurrentUnit;
2139
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
2140
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2141
 
2142
   switch (coord) {
2143
      case GL_S:
2144
         if (pname==GL_TEXTURE_GEN_MODE) {
2145
            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeS);
2146
         }
2147
         else if (pname==GL_OBJECT_PLANE) {
2148
            COPY_4V( params, texUnit->ObjectPlaneS );
2149
         }
2150
         else if (pname==GL_EYE_PLANE) {
2151
            COPY_4V( params, texUnit->EyePlaneS );
2152
         }
2153
         else {
2154
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
2155
            return;
2156
         }
2157
         break;
2158
      case GL_T:
2159
         if (pname==GL_TEXTURE_GEN_MODE) {
2160
            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeT);
2161
         }
2162
         else if (pname==GL_OBJECT_PLANE) {
2163
            COPY_4V( params, texUnit->ObjectPlaneT );
2164
         }
2165
         else if (pname==GL_EYE_PLANE) {
2166
            COPY_4V( params, texUnit->EyePlaneT );
2167
         }
2168
         else {
2169
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
2170
            return;
2171
         }
2172
         break;
2173
      case GL_R:
2174
         if (pname==GL_TEXTURE_GEN_MODE) {
2175
            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeR);
2176
         }
2177
         else if (pname==GL_OBJECT_PLANE) {
2178
            COPY_4V( params, texUnit->ObjectPlaneR );
2179
         }
2180
         else if (pname==GL_EYE_PLANE) {
2181
            COPY_4V( params, texUnit->EyePlaneR );
2182
         }
2183
         else {
2184
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
2185
            return;
2186
         }
2187
         break;
2188
      case GL_Q:
2189
         if (pname==GL_TEXTURE_GEN_MODE) {
2190
            params[0] = ENUM_TO_DOUBLE(texUnit->GenModeQ);
2191
         }
2192
         else if (pname==GL_OBJECT_PLANE) {
2193
            COPY_4V( params, texUnit->ObjectPlaneQ );
2194
         }
2195
         else if (pname==GL_EYE_PLANE) {
2196
            COPY_4V( params, texUnit->EyePlaneQ );
2197
         }
2198
         else {
2199
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(pname)" );
2200
            return;
2201
         }
2202
         break;
2203
      default:
2204
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGendv(coord)" );
2205
         return;
2206
   }
2207
}
2208
 
2209
 
2210
 
2211
void
2212
_mesa_GetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
2213
{
2214
   GET_CURRENT_CONTEXT(ctx);
2215
   GLuint tUnit = ctx->Texture.CurrentUnit;
2216
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
2217
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2218
 
2219
   switch (coord) {
2220
      case GL_S:
2221
         if (pname==GL_TEXTURE_GEN_MODE) {
2222
            params[0] = ENUM_TO_FLOAT(texUnit->GenModeS);
2223
         }
2224
         else if (pname==GL_OBJECT_PLANE) {
2225
            COPY_4V( params, texUnit->ObjectPlaneS );
2226
         }
2227
         else if (pname==GL_EYE_PLANE) {
2228
            COPY_4V( params, texUnit->EyePlaneS );
2229
         }
2230
         else {
2231
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
2232
            return;
2233
         }
2234
         break;
2235
      case GL_T:
2236
         if (pname==GL_TEXTURE_GEN_MODE) {
2237
            params[0] = ENUM_TO_FLOAT(texUnit->GenModeT);
2238
         }
2239
         else if (pname==GL_OBJECT_PLANE) {
2240
            COPY_4V( params, texUnit->ObjectPlaneT );
2241
         }
2242
         else if (pname==GL_EYE_PLANE) {
2243
            COPY_4V( params, texUnit->EyePlaneT );
2244
         }
2245
         else {
2246
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
2247
            return;
2248
         }
2249
         break;
2250
      case GL_R:
2251
         if (pname==GL_TEXTURE_GEN_MODE) {
2252
            params[0] = ENUM_TO_FLOAT(texUnit->GenModeR);
2253
         }
2254
         else if (pname==GL_OBJECT_PLANE) {
2255
            COPY_4V( params, texUnit->ObjectPlaneR );
2256
         }
2257
         else if (pname==GL_EYE_PLANE) {
2258
            COPY_4V( params, texUnit->EyePlaneR );
2259
         }
2260
         else {
2261
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
2262
            return;
2263
         }
2264
         break;
2265
      case GL_Q:
2266
         if (pname==GL_TEXTURE_GEN_MODE) {
2267
            params[0] = ENUM_TO_FLOAT(texUnit->GenModeQ);
2268
         }
2269
         else if (pname==GL_OBJECT_PLANE) {
2270
            COPY_4V( params, texUnit->ObjectPlaneQ );
2271
         }
2272
         else if (pname==GL_EYE_PLANE) {
2273
            COPY_4V( params, texUnit->EyePlaneQ );
2274
         }
2275
         else {
2276
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(pname)" );
2277
            return;
2278
         }
2279
         break;
2280
      default:
2281
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGenfv(coord)" );
2282
         return;
2283
   }
2284
}
2285
 
2286
 
2287
 
2288
void
2289
_mesa_GetTexGeniv( GLenum coord, GLenum pname, GLint *params )
2290
{
2291
   GET_CURRENT_CONTEXT(ctx);
2292
   GLuint tUnit = ctx->Texture.CurrentUnit;
2293
   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[tUnit];
2294
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2295
 
2296
   switch (coord) {
2297
      case GL_S:
2298
         if (pname==GL_TEXTURE_GEN_MODE) {
2299
            params[0] = texUnit->GenModeS;
2300
         }
2301
         else if (pname==GL_OBJECT_PLANE) {
2302
            params[0] = (GLint) texUnit->ObjectPlaneS[0];
2303
            params[1] = (GLint) texUnit->ObjectPlaneS[1];
2304
            params[2] = (GLint) texUnit->ObjectPlaneS[2];
2305
            params[3] = (GLint) texUnit->ObjectPlaneS[3];
2306
         }
2307
         else if (pname==GL_EYE_PLANE) {
2308
            params[0] = (GLint) texUnit->EyePlaneS[0];
2309
            params[1] = (GLint) texUnit->EyePlaneS[1];
2310
            params[2] = (GLint) texUnit->EyePlaneS[2];
2311
            params[3] = (GLint) texUnit->EyePlaneS[3];
2312
         }
2313
         else {
2314
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
2315
            return;
2316
         }
2317
         break;
2318
      case GL_T:
2319
         if (pname==GL_TEXTURE_GEN_MODE) {
2320
            params[0] = texUnit->GenModeT;
2321
         }
2322
         else if (pname==GL_OBJECT_PLANE) {
2323
            params[0] = (GLint) texUnit->ObjectPlaneT[0];
2324
            params[1] = (GLint) texUnit->ObjectPlaneT[1];
2325
            params[2] = (GLint) texUnit->ObjectPlaneT[2];
2326
            params[3] = (GLint) texUnit->ObjectPlaneT[3];
2327
         }
2328
         else if (pname==GL_EYE_PLANE) {
2329
            params[0] = (GLint) texUnit->EyePlaneT[0];
2330
            params[1] = (GLint) texUnit->EyePlaneT[1];
2331
            params[2] = (GLint) texUnit->EyePlaneT[2];
2332
            params[3] = (GLint) texUnit->EyePlaneT[3];
2333
         }
2334
         else {
2335
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
2336
            return;
2337
         }
2338
         break;
2339
      case GL_R:
2340
         if (pname==GL_TEXTURE_GEN_MODE) {
2341
            params[0] = texUnit->GenModeR;
2342
         }
2343
         else if (pname==GL_OBJECT_PLANE) {
2344
            params[0] = (GLint) texUnit->ObjectPlaneR[0];
2345
            params[1] = (GLint) texUnit->ObjectPlaneR[1];
2346
            params[2] = (GLint) texUnit->ObjectPlaneR[2];
2347
            params[3] = (GLint) texUnit->ObjectPlaneR[3];
2348
         }
2349
         else if (pname==GL_EYE_PLANE) {
2350
            params[0] = (GLint) texUnit->EyePlaneR[0];
2351
            params[1] = (GLint) texUnit->EyePlaneR[1];
2352
            params[2] = (GLint) texUnit->EyePlaneR[2];
2353
            params[3] = (GLint) texUnit->EyePlaneR[3];
2354
         }
2355
         else {
2356
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
2357
            return;
2358
         }
2359
         break;
2360
      case GL_Q:
2361
         if (pname==GL_TEXTURE_GEN_MODE) {
2362
            params[0] = texUnit->GenModeQ;
2363
         }
2364
         else if (pname==GL_OBJECT_PLANE) {
2365
            params[0] = (GLint) texUnit->ObjectPlaneQ[0];
2366
            params[1] = (GLint) texUnit->ObjectPlaneQ[1];
2367
            params[2] = (GLint) texUnit->ObjectPlaneQ[2];
2368
            params[3] = (GLint) texUnit->ObjectPlaneQ[3];
2369
         }
2370
         else if (pname==GL_EYE_PLANE) {
2371
            params[0] = (GLint) texUnit->EyePlaneQ[0];
2372
            params[1] = (GLint) texUnit->EyePlaneQ[1];
2373
            params[2] = (GLint) texUnit->EyePlaneQ[2];
2374
            params[3] = (GLint) texUnit->EyePlaneQ[3];
2375
         }
2376
         else {
2377
            _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(pname)" );
2378
            return;
2379
         }
2380
         break;
2381
      default:
2382
         _mesa_error( ctx, GL_INVALID_ENUM, "glGetTexGeniv(coord)" );
2383
         return;
2384
   }
2385
}
2386
 
2387
 
2388
/* GL_ARB_multitexture */
2389
void
2390
_mesa_ActiveTextureARB( GLenum target )
2391
{
2392
   GET_CURRENT_CONTEXT(ctx);
2393
   GLuint texUnit = target - GL_TEXTURE0_ARB;
2394
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2395
 
2396
   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
2397
      _mesa_debug(ctx, "glActiveTexture %s\n",
2398
                  _mesa_lookup_enum_by_nr(target));
2399
 
2400
   if (texUnit > ctx->Const.MaxTextureUnits) {
2401
      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTextureARB(target)");
2402
      return;
2403
   }
2404
 
2405
   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
2406
   ctx->Texture.CurrentUnit = texUnit;
2407
   if (ctx->Driver.ActiveTexture) {
2408
      (*ctx->Driver.ActiveTexture)( ctx, (GLuint) texUnit );
2409
   }
2410
}
2411
 
2412
 
2413
/* GL_ARB_multitexture */
2414
void
2415
_mesa_ClientActiveTextureARB( GLenum target )
2416
{
2417
   GET_CURRENT_CONTEXT(ctx);
2418
   GLuint texUnit = target - GL_TEXTURE0_ARB;
2419
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2420
 
2421
   if (texUnit > ctx->Const.MaxTextureUnits) {
2422
      _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTextureARB(target)");
2423
      return;
2424
   }
2425
 
2426
   FLUSH_VERTICES(ctx, _NEW_ARRAY);
2427
   ctx->Array.ActiveTexture = texUnit;
2428
}
2429
 
2430
 
2431
 
2432
/**********************************************************************/
2433
/*                     Pixel Texgen Extensions                        */
2434
/**********************************************************************/
2435
 
2436
void
2437
_mesa_PixelTexGenSGIX(GLenum mode)
2438
{
2439
   GLenum newRgbSource, newAlphaSource;
2440
   GET_CURRENT_CONTEXT(ctx);
2441
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2442
 
2443
   switch (mode) {
2444
      case GL_NONE:
2445
         newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
2446
         newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
2447
         break;
2448
      case GL_ALPHA:
2449
         newRgbSource = GL_PIXEL_GROUP_COLOR_SGIS;
2450
         newAlphaSource = GL_CURRENT_RASTER_COLOR;
2451
         break;
2452
      case GL_RGB:
2453
         newRgbSource = GL_CURRENT_RASTER_COLOR;
2454
         newAlphaSource = GL_PIXEL_GROUP_COLOR_SGIS;
2455
         break;
2456
      case GL_RGBA:
2457
         newRgbSource = GL_CURRENT_RASTER_COLOR;
2458
         newAlphaSource = GL_CURRENT_RASTER_COLOR;
2459
         break;
2460
      default:
2461
         _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenSGIX(mode)");
2462
         return;
2463
   }
2464
 
2465
   if (newRgbSource == ctx->Pixel.FragmentRgbSource &&
2466
       newAlphaSource == ctx->Pixel.FragmentAlphaSource)
2467
      return;
2468
 
2469
   FLUSH_VERTICES(ctx, _NEW_PIXEL);
2470
   ctx->Pixel.FragmentRgbSource = newRgbSource;
2471
   ctx->Pixel.FragmentAlphaSource = newAlphaSource;
2472
}
2473
 
2474
 
2475
void
2476
_mesa_PixelTexGenParameterfSGIS(GLenum target, GLfloat value)
2477
{
2478
   _mesa_PixelTexGenParameteriSGIS(target, (GLint) value);
2479
}
2480
 
2481
 
2482
void
2483
_mesa_PixelTexGenParameterfvSGIS(GLenum target, const GLfloat *value)
2484
{
2485
   _mesa_PixelTexGenParameteriSGIS(target, (GLint) *value);
2486
}
2487
 
2488
 
2489
void
2490
_mesa_PixelTexGenParameteriSGIS(GLenum target, GLint value)
2491
{
2492
   GET_CURRENT_CONTEXT(ctx);
2493
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2494
 
2495
   if (value != GL_CURRENT_RASTER_COLOR && value != GL_PIXEL_GROUP_COLOR_SGIS) {
2496
      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(value)");
2497
      return;
2498
   }
2499
 
2500
   switch (target) {
2501
   case GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS:
2502
      if (ctx->Pixel.FragmentRgbSource == (GLenum) value)
2503
         return;
2504
      FLUSH_VERTICES(ctx, _NEW_PIXEL);
2505
      ctx->Pixel.FragmentRgbSource = (GLenum) value;
2506
      break;
2507
   case GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS:
2508
      if (ctx->Pixel.FragmentAlphaSource == (GLenum) value)
2509
         return;
2510
      FLUSH_VERTICES(ctx, _NEW_PIXEL);
2511
      ctx->Pixel.FragmentAlphaSource = (GLenum) value;
2512
      break;
2513
   default:
2514
      _mesa_error(ctx, GL_INVALID_ENUM, "glPixelTexGenParameterSGIS(target)");
2515
      return;
2516
   }
2517
}
2518
 
2519
 
2520
void
2521
_mesa_PixelTexGenParameterivSGIS(GLenum target, const GLint *value)
2522
{
2523
  _mesa_PixelTexGenParameteriSGIS(target, *value);
2524
}
2525
 
2526
 
2527
void
2528
_mesa_GetPixelTexGenParameterfvSGIS(GLenum target, GLfloat *value)
2529
{
2530
   GET_CURRENT_CONTEXT(ctx);
2531
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2532
 
2533
   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
2534
      *value = (GLfloat) ctx->Pixel.FragmentRgbSource;
2535
   }
2536
   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
2537
      *value = (GLfloat) ctx->Pixel.FragmentAlphaSource;
2538
   }
2539
   else {
2540
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterfvSGIS(target)");
2541
   }
2542
}
2543
 
2544
 
2545
void
2546
_mesa_GetPixelTexGenParameterivSGIS(GLenum target, GLint *value)
2547
{
2548
   GET_CURRENT_CONTEXT(ctx);
2549
   ASSERT_OUTSIDE_BEGIN_END(ctx);
2550
 
2551
   if (target == GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS) {
2552
      *value = (GLint) ctx->Pixel.FragmentRgbSource;
2553
   }
2554
   else if (target == GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS) {
2555
      *value = (GLint) ctx->Pixel.FragmentAlphaSource;
2556
   }
2557
   else {
2558
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetPixelTexGenParameterivSGIS(target)");
2559
   }
2560
}