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