1/*
2 * Mesa 3-D graphics library
3 * Version:  7.5
4 *
5 * Copyright (C) 1999-2007  Brian Paul   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 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25/**
26 * \file texstate.c
27 *
28 * Texture state handling.
29 */
30
31#include "glheader.h"
32#include "mfeatures.h"
33#include "bufferobj.h"
34#include "colormac.h"
35#include "colortab.h"
36#include "context.h"
37#include "enums.h"
38#include "macros.h"
39#include "texobj.h"
40#include "teximage.h"
41#include "texstate.h"
42#include "mtypes.h"
43
44
45
46/**
47 * Default texture combine environment state.  This is used to initialize
48 * a context's texture units and as the basis for converting "classic"
49 * texture environmnets to ARB_texture_env_combine style values.
50 */
51static const struct gl_tex_env_combine_state default_combine_state = {
52   GL_MODULATE, GL_MODULATE,
53   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
54   { GL_TEXTURE, GL_PREVIOUS, GL_CONSTANT, GL_CONSTANT },
55   { GL_SRC_COLOR, GL_SRC_COLOR, GL_SRC_ALPHA, GL_SRC_ALPHA },
56   { GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA, GL_SRC_ALPHA },
57   0, 0,
58   2, 2
59};
60
61
62
63/**
64 * Used by glXCopyContext to copy texture state from one context to another.
65 */
66void
67_mesa_copy_texture_state( const struct gl_context *src, struct gl_context *dst )
68{
69   GLuint u, tex;
70
71   ASSERT(src);
72   ASSERT(dst);
73
74   dst->Texture.CurrentUnit = src->Texture.CurrentUnit;
75   dst->Texture._GenFlags = src->Texture._GenFlags;
76   dst->Texture._TexGenEnabled = src->Texture._TexGenEnabled;
77   dst->Texture._TexMatEnabled = src->Texture._TexMatEnabled;
78
79   /* per-unit state */
80   for (u = 0; u < src->Const.MaxCombinedTextureImageUnits; u++) {
81      dst->Texture.Unit[u].Enabled = src->Texture.Unit[u].Enabled;
82      dst->Texture.Unit[u].EnvMode = src->Texture.Unit[u].EnvMode;
83      COPY_4V(dst->Texture.Unit[u].EnvColor, src->Texture.Unit[u].EnvColor);
84      dst->Texture.Unit[u].TexGenEnabled = src->Texture.Unit[u].TexGenEnabled;
85      dst->Texture.Unit[u].GenS = src->Texture.Unit[u].GenS;
86      dst->Texture.Unit[u].GenT = src->Texture.Unit[u].GenT;
87      dst->Texture.Unit[u].GenR = src->Texture.Unit[u].GenR;
88      dst->Texture.Unit[u].GenQ = src->Texture.Unit[u].GenQ;
89      dst->Texture.Unit[u].LodBias = src->Texture.Unit[u].LodBias;
90
91      /* GL_EXT_texture_env_combine */
92      dst->Texture.Unit[u].Combine = src->Texture.Unit[u].Combine;
93
94      /* GL_ATI_envmap_bumpmap - need this? */
95      dst->Texture.Unit[u].BumpTarget = src->Texture.Unit[u].BumpTarget;
96      COPY_4V(dst->Texture.Unit[u].RotMatrix, src->Texture.Unit[u].RotMatrix);
97
98      /*
99       * XXX strictly speaking, we should compare texture names/ids and
100       * bind textures in the dest context according to id.  For now, only
101       * copy bindings if the contexts share the same pool of textures to
102       * avoid refcounting bugs.
103       */
104      if (dst->Shared == src->Shared) {
105         /* copy texture object bindings, not contents of texture objects */
106         _mesa_lock_context_textures(dst);
107
108         for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
109            _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],
110                                   src->Texture.Unit[u].CurrentTex[tex]);
111         }
112         _mesa_unlock_context_textures(dst);
113      }
114   }
115}
116
117
118/*
119 * For debugging
120 */
121void
122_mesa_print_texunit_state( struct gl_context *ctx, GLuint unit )
123{
124   const struct gl_texture_unit *texUnit = ctx->Texture.Unit + unit;
125   printf("Texture Unit %d\n", unit);
126   printf("  GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit->EnvMode));
127   printf("  GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeRGB));
128   printf("  GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.ModeA));
129   printf("  GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[0]));
130   printf("  GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[1]));
131   printf("  GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceRGB[2]));
132   printf("  GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[0]));
133   printf("  GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[1]));
134   printf("  GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.SourceA[2]));
135   printf("  GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[0]));
136   printf("  GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[1]));
137   printf("  GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandRGB[2]));
138   printf("  GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[0]));
139   printf("  GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[1]));
140   printf("  GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit->Combine.OperandA[2]));
141   printf("  GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
142   printf("  GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
143   printf("  GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
144}
145
146
147
148/**********************************************************************/
149/*                       Texture Environment                          */
150/**********************************************************************/
151
152/**
153 * Convert "classic" texture environment to ARB_texture_env_combine style
154 * environments.
155 *
156 * \param state  texture_env_combine state vector to be filled-in.
157 * \param mode   Classic texture environment mode (i.e., \c GL_REPLACE,
158 *               \c GL_BLEND, \c GL_DECAL, etc.).
159 * \param texBaseFormat  Base format of the texture associated with the
160 *               texture unit.
161 */
162static void
163calculate_derived_texenv( struct gl_tex_env_combine_state *state,
164			  GLenum mode, GLenum texBaseFormat )
165{
166   GLenum mode_rgb;
167   GLenum mode_a;
168
169   *state = default_combine_state;
170
171   switch (texBaseFormat) {
172   case GL_ALPHA:
173      state->SourceRGB[0] = GL_PREVIOUS;
174      break;
175
176   case GL_LUMINANCE_ALPHA:
177   case GL_INTENSITY:
178   case GL_RGBA:
179      break;
180
181   case GL_LUMINANCE:
182   case GL_RED:
183   case GL_RG:
184   case GL_RGB:
185   case GL_YCBCR_MESA:
186   case GL_DUDV_ATI:
187      state->SourceA[0] = GL_PREVIOUS;
188      break;
189
190   default:
191      _mesa_problem(NULL,
192                    "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
193                    texBaseFormat);
194      return;
195   }
196
197   if (mode == GL_REPLACE_EXT)
198      mode = GL_REPLACE;
199
200   switch (mode) {
201   case GL_REPLACE:
202   case GL_MODULATE:
203      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode;
204      mode_a   = mode;
205      break;
206
207   case GL_DECAL:
208      mode_rgb = GL_INTERPOLATE;
209      mode_a   = GL_REPLACE;
210
211      state->SourceA[0] = GL_PREVIOUS;
212
213      /* Having alpha / luminance / intensity textures replace using the
214       * incoming fragment color matches the definition in NV_texture_shader.
215       * The 1.5 spec simply marks these as "undefined".
216       */
217      switch (texBaseFormat) {
218      case GL_ALPHA:
219      case GL_LUMINANCE:
220      case GL_LUMINANCE_ALPHA:
221      case GL_INTENSITY:
222	 state->SourceRGB[0] = GL_PREVIOUS;
223	 break;
224      case GL_RED:
225      case GL_RG:
226      case GL_RGB:
227      case GL_YCBCR_MESA:
228      case GL_DUDV_ATI:
229	 mode_rgb = GL_REPLACE;
230	 break;
231      case GL_RGBA:
232	 state->SourceRGB[2] = GL_TEXTURE;
233	 break;
234      }
235      break;
236
237   case GL_BLEND:
238      mode_rgb = GL_INTERPOLATE;
239      mode_a   = GL_MODULATE;
240
241      switch (texBaseFormat) {
242      case GL_ALPHA:
243	 mode_rgb = GL_REPLACE;
244	 break;
245      case GL_INTENSITY:
246	 mode_a = GL_INTERPOLATE;
247	 state->SourceA[0] = GL_CONSTANT;
248	 state->OperandA[2] = GL_SRC_ALPHA;
249	 /* FALLTHROUGH */
250      case GL_LUMINANCE:
251      case GL_RED:
252      case GL_RG:
253      case GL_RGB:
254      case GL_LUMINANCE_ALPHA:
255      case GL_RGBA:
256      case GL_YCBCR_MESA:
257      case GL_DUDV_ATI:
258	 state->SourceRGB[2] = GL_TEXTURE;
259	 state->SourceA[2]   = GL_TEXTURE;
260	 state->SourceRGB[0] = GL_CONSTANT;
261	 state->OperandRGB[2] = GL_SRC_COLOR;
262	 break;
263      }
264      break;
265
266   case GL_ADD:
267      mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : GL_ADD;
268      mode_a   = (texBaseFormat == GL_INTENSITY) ? GL_ADD : GL_MODULATE;
269      break;
270
271   default:
272      _mesa_problem(NULL,
273                    "Invalid texture env mode 0x%x in calculate_derived_texenv",
274                    mode);
275      return;
276   }
277
278   state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS)
279       ? mode_rgb : GL_REPLACE;
280   state->ModeA   = (state->SourceA[0]   != GL_PREVIOUS)
281       ? mode_a   : GL_REPLACE;
282}
283
284
285
286
287/* GL_ARB_multitexture */
288void GLAPIENTRY
289_mesa_ActiveTextureARB(GLenum texture)
290{
291   const GLuint texUnit = texture - GL_TEXTURE0;
292   GLuint k;
293   GET_CURRENT_CONTEXT(ctx);
294
295   /* See OpenGL spec for glActiveTexture: */
296   k = MAX2(ctx->Const.MaxCombinedTextureImageUnits,
297            ctx->Const.MaxTextureCoordUnits);
298
299   ASSERT(k <= Elements(ctx->Texture.Unit));
300
301   ASSERT_OUTSIDE_BEGIN_END(ctx);
302
303   if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
304      _mesa_debug(ctx, "glActiveTexture %s\n",
305                  _mesa_lookup_enum_by_nr(texture));
306
307   if (texUnit >= k) {
308      _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)",
309                  _mesa_lookup_enum_by_nr(texture));
310      return;
311   }
312
313   if (ctx->Texture.CurrentUnit == texUnit)
314      return;
315
316   FLUSH_VERTICES(ctx, _NEW_TEXTURE);
317
318   ctx->Texture.CurrentUnit = texUnit;
319   if (ctx->Transform.MatrixMode == GL_TEXTURE) {
320      /* update current stack pointer */
321      ctx->CurrentStack = &ctx->TextureMatrixStack[texUnit];
322   }
323}
324
325
326/* GL_ARB_multitexture */
327void GLAPIENTRY
328_mesa_ClientActiveTextureARB(GLenum texture)
329{
330   GET_CURRENT_CONTEXT(ctx);
331   GLuint texUnit = texture - GL_TEXTURE0;
332   ASSERT_OUTSIDE_BEGIN_END(ctx);
333
334   if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE))
335      _mesa_debug(ctx, "glClientActiveTexture %s\n",
336                  _mesa_lookup_enum_by_nr(texture));
337
338   if (texUnit >= ctx->Const.MaxTextureCoordUnits) {
339      _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture)");
340      return;
341   }
342
343   if (ctx->Array.ActiveTexture == texUnit)
344      return;
345
346   FLUSH_VERTICES(ctx, _NEW_ARRAY);
347   ctx->Array.ActiveTexture = texUnit;
348}
349
350
351
352/**********************************************************************/
353/*****                    State management                        *****/
354/**********************************************************************/
355
356
357/**
358 * \note This routine refers to derived texture attribute values to
359 * compute the ENABLE_TEXMAT flags, but is only called on
360 * _NEW_TEXTURE_MATRIX.  On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
361 * flags are updated by _mesa_update_textures(), below.
362 *
363 * \param ctx GL context.
364 */
365static void
366update_texture_matrices( struct gl_context *ctx )
367{
368   GLuint u;
369
370   ctx->Texture._TexMatEnabled = 0x0;
371
372   for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {
373      ASSERT(u < Elements(ctx->TextureMatrixStack));
374      if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {
375	 _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );
376
377	 if (ctx->Texture.Unit[u]._ReallyEnabled &&
378	     ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)
379	    ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);
380      }
381   }
382}
383
384
385/**
386 * Examine texture unit's combine/env state to update derived state.
387 */
388static void
389update_tex_combine(struct gl_context *ctx, struct gl_texture_unit *texUnit)
390{
391   struct gl_tex_env_combine_state *combine;
392
393   /* No combiners will apply to this. */
394   if (texUnit->_Current->Target == GL_TEXTURE_BUFFER)
395      return;
396
397   /* Set the texUnit->_CurrentCombine field to point to the user's combiner
398    * state, or the combiner state which is derived from traditional texenv
399    * mode.
400    */
401   if (texUnit->EnvMode == GL_COMBINE ||
402       texUnit->EnvMode == GL_COMBINE4_NV) {
403      texUnit->_CurrentCombine = & texUnit->Combine;
404   }
405   else {
406      const struct gl_texture_object *texObj = texUnit->_Current;
407      GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
408
409      if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
410         format = texObj->DepthMode;
411      }
412      calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
413      texUnit->_CurrentCombine = & texUnit->_EnvMode;
414   }
415
416   combine = texUnit->_CurrentCombine;
417
418   /* Determine number of source RGB terms in the combiner function */
419   switch (combine->ModeRGB) {
420   case GL_REPLACE:
421      combine->_NumArgsRGB = 1;
422      break;
423   case GL_ADD:
424   case GL_ADD_SIGNED:
425      if (texUnit->EnvMode == GL_COMBINE4_NV)
426         combine->_NumArgsRGB = 4;
427      else
428         combine->_NumArgsRGB = 2;
429      break;
430   case GL_MODULATE:
431   case GL_SUBTRACT:
432   case GL_DOT3_RGB:
433   case GL_DOT3_RGBA:
434   case GL_DOT3_RGB_EXT:
435   case GL_DOT3_RGBA_EXT:
436      combine->_NumArgsRGB = 2;
437      break;
438   case GL_INTERPOLATE:
439   case GL_MODULATE_ADD_ATI:
440   case GL_MODULATE_SIGNED_ADD_ATI:
441   case GL_MODULATE_SUBTRACT_ATI:
442      combine->_NumArgsRGB = 3;
443      break;
444   case GL_BUMP_ENVMAP_ATI:
445      /* no real arguments for this case */
446      combine->_NumArgsRGB = 0;
447      break;
448   default:
449      combine->_NumArgsRGB = 0;
450      _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
451      return;
452   }
453
454   /* Determine number of source Alpha terms in the combiner function */
455   switch (combine->ModeA) {
456   case GL_REPLACE:
457      combine->_NumArgsA = 1;
458      break;
459   case GL_ADD:
460   case GL_ADD_SIGNED:
461      if (texUnit->EnvMode == GL_COMBINE4_NV)
462         combine->_NumArgsA = 4;
463      else
464         combine->_NumArgsA = 2;
465      break;
466   case GL_MODULATE:
467   case GL_SUBTRACT:
468      combine->_NumArgsA = 2;
469      break;
470   case GL_INTERPOLATE:
471   case GL_MODULATE_ADD_ATI:
472   case GL_MODULATE_SIGNED_ADD_ATI:
473   case GL_MODULATE_SUBTRACT_ATI:
474      combine->_NumArgsA = 3;
475      break;
476   default:
477      combine->_NumArgsA = 0;
478      _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
479      break;
480   }
481}
482
483
484/**
485 * \note This routine refers to derived texture matrix values to
486 * compute the ENABLE_TEXMAT flags, but is only called on
487 * _NEW_TEXTURE.  On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
488 * flags are updated by _mesa_update_texture_matrices, above.
489 *
490 * \param ctx GL context.
491 */
492static void
493update_texture_state( struct gl_context *ctx )
494{
495   GLuint unit;
496   struct gl_program *fprog = NULL;
497   struct gl_program *vprog = NULL;
498   GLbitfield enabledFragUnits = 0x0;
499
500   if (ctx->Shader.CurrentVertexProgram &&
501       ctx->Shader.CurrentVertexProgram->LinkStatus) {
502      vprog = ctx->Shader.CurrentVertexProgram->_LinkedShaders[MESA_SHADER_VERTEX]->Program;
503   } else if (ctx->VertexProgram._Enabled) {
504      /* XXX enable this if/when non-shader vertex programs get
505       * texture fetches:
506       vprog = &ctx->VertexProgram.Current->Base;
507       */
508   }
509
510   if (ctx->Shader.CurrentFragmentProgram &&
511       ctx->Shader.CurrentFragmentProgram->LinkStatus) {
512      fprog = ctx->Shader.CurrentFragmentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]->Program;
513   }
514   else if (ctx->FragmentProgram._Enabled) {
515      fprog = &ctx->FragmentProgram.Current->Base;
516   }
517
518   /* FINISHME: Geometry shader texture accesses should also be considered
519    * FINISHME: here.
520    */
521
522   /* TODO: only set this if there are actual changes */
523   ctx->NewState |= _NEW_TEXTURE;
524
525   ctx->Texture._EnabledUnits = 0x0;
526   ctx->Texture._GenFlags = 0x0;
527   ctx->Texture._TexMatEnabled = 0x0;
528   ctx->Texture._TexGenEnabled = 0x0;
529
530   /*
531    * Update texture unit state.
532    */
533   for (unit = 0; unit < ctx->Const.MaxCombinedTextureImageUnits; unit++) {
534      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
535      GLbitfield enabledVertTargets = 0x0;
536      GLbitfield enabledFragTargets = 0x0;
537      GLbitfield enabledTargets = 0x0;
538      GLuint texIndex;
539
540      /* Get the bitmask of texture target enables.
541       * enableBits will be a mask of the TEXTURE_*_BIT flags indicating
542       * which texture targets are enabled (fixed function) or referenced
543       * by a fragment program/program.  When multiple flags are set, we'll
544       * settle on the one with highest priority (see below).
545       */
546      if (vprog) {
547         enabledVertTargets |= vprog->TexturesUsed[unit];
548      }
549
550      if (fprog) {
551         enabledFragTargets |= fprog->TexturesUsed[unit];
552      }
553      else {
554         /* fixed-function fragment program */
555         enabledFragTargets |= texUnit->Enabled;
556      }
557
558      enabledTargets = enabledVertTargets | enabledFragTargets;
559
560      texUnit->_ReallyEnabled = 0x0;
561
562      if (enabledTargets == 0x0) {
563         /* neither vertex nor fragment processing uses this unit */
564         continue;
565      }
566
567      /* Look for the highest priority texture target that's enabled (or used
568       * by the vert/frag shaders) and "complete".  That's the one we'll use
569       * for texturing.  If we're using vert/frag program we're guaranteed
570       * that bitcount(enabledBits) <= 1.
571       * Note that the TEXTURE_x_INDEX values are in high to low priority.
572       */
573      for (texIndex = 0; texIndex < NUM_TEXTURE_TARGETS; texIndex++) {
574         if (enabledTargets & (1 << texIndex)) {
575            struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
576            struct gl_sampler_object *sampler = texUnit->Sampler ?
577               texUnit->Sampler : &texObj->Sampler;
578
579            if (!_mesa_is_texture_complete(texObj, sampler)) {
580               _mesa_test_texobj_completeness(ctx, texObj);
581            }
582            if (_mesa_is_texture_complete(texObj, sampler)) {
583               texUnit->_ReallyEnabled = 1 << texIndex;
584               _mesa_reference_texobj(&texUnit->_Current, texObj);
585               break;
586            }
587         }
588      }
589
590      if (!texUnit->_ReallyEnabled) {
591         if (fprog) {
592            /* If we get here it means the shader is expecting a texture
593             * object, but there isn't one (or it's incomplete).  Use the
594             * fallback texture.
595             */
596            struct gl_texture_object *texObj;
597            gl_texture_index texTarget;
598
599            assert(_mesa_bitcount(enabledTargets) == 1);
600
601            texTarget = (gl_texture_index) (ffs(enabledTargets) - 1);
602            texObj = _mesa_get_fallback_texture(ctx, texTarget);
603
604            assert(texObj);
605            if (!texObj) {
606               /* invalid fallback texture: don't enable the texture unit */
607               continue;
608            }
609
610            _mesa_reference_texobj(&texUnit->_Current, texObj);
611            texUnit->_ReallyEnabled = 1 << texTarget;
612         }
613         else {
614            /* fixed-function: texture unit is really disabled */
615            continue;
616         }
617      }
618
619      /* if we get here, we know this texture unit is enabled */
620
621      ctx->Texture._EnabledUnits |= (1 << unit);
622
623      if (enabledFragTargets)
624         enabledFragUnits |= (1 << unit);
625
626      update_tex_combine(ctx, texUnit);
627   }
628
629
630   /* Determine which texture coordinate sets are actually needed */
631   if (fprog) {
632      const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
633      ctx->Texture._EnabledCoordUnits
634         = (fprog->InputsRead >> FRAG_ATTRIB_TEX0) & coordMask;
635   }
636   else {
637      ctx->Texture._EnabledCoordUnits = enabledFragUnits;
638   }
639
640   /* Setup texgen for those texture coordinate sets that are in use */
641   for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {
642      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
643
644      texUnit->_GenFlags = 0x0;
645
646      if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))
647	 continue;
648
649      if (texUnit->TexGenEnabled) {
650	 if (texUnit->TexGenEnabled & S_BIT) {
651	    texUnit->_GenFlags |= texUnit->GenS._ModeBit;
652	 }
653	 if (texUnit->TexGenEnabled & T_BIT) {
654	    texUnit->_GenFlags |= texUnit->GenT._ModeBit;
655	 }
656	 if (texUnit->TexGenEnabled & R_BIT) {
657	    texUnit->_GenFlags |= texUnit->GenR._ModeBit;
658	 }
659	 if (texUnit->TexGenEnabled & Q_BIT) {
660	    texUnit->_GenFlags |= texUnit->GenQ._ModeBit;
661	 }
662
663	 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);
664	 ctx->Texture._GenFlags |= texUnit->_GenFlags;
665      }
666
667      ASSERT(unit < Elements(ctx->TextureMatrixStack));
668      if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY)
669	 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit);
670   }
671}
672
673
674/**
675 * Update texture-related derived state.
676 */
677void
678_mesa_update_texture( struct gl_context *ctx, GLuint new_state )
679{
680   if (new_state & _NEW_TEXTURE_MATRIX)
681      update_texture_matrices( ctx );
682
683   if (new_state & (_NEW_TEXTURE | _NEW_PROGRAM))
684      update_texture_state( ctx );
685}
686
687
688/**********************************************************************/
689/*****                      Initialization                        *****/
690/**********************************************************************/
691
692/**
693 * Allocate the proxy textures for the given context.
694 *
695 * \param ctx the context to allocate proxies for.
696 *
697 * \return GL_TRUE on success, or GL_FALSE on failure
698 *
699 * If run out of memory part way through the allocations, clean up and return
700 * GL_FALSE.
701 */
702static GLboolean
703alloc_proxy_textures( struct gl_context *ctx )
704{
705   /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
706    * values!
707    */
708   static const GLenum targets[] = {
709      GL_TEXTURE_BUFFER,
710      GL_TEXTURE_2D_ARRAY_EXT,
711      GL_TEXTURE_1D_ARRAY_EXT,
712      GL_TEXTURE_EXTERNAL_OES,
713      GL_TEXTURE_CUBE_MAP_ARB,
714      GL_TEXTURE_3D,
715      GL_TEXTURE_RECTANGLE_NV,
716      GL_TEXTURE_2D,
717      GL_TEXTURE_1D,
718   };
719   GLint tgt;
720
721   STATIC_ASSERT(Elements(targets) == NUM_TEXTURE_TARGETS);
722   assert(targets[TEXTURE_2D_INDEX] == GL_TEXTURE_2D);
723   assert(targets[TEXTURE_CUBE_INDEX] == GL_TEXTURE_CUBE_MAP);
724
725   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
726      if (!(ctx->Texture.ProxyTex[tgt]
727            = ctx->Driver.NewTextureObject(ctx, 0, targets[tgt]))) {
728         /* out of memory, free what we did allocate */
729         while (--tgt >= 0) {
730            ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
731         }
732         return GL_FALSE;
733      }
734   }
735
736   assert(ctx->Texture.ProxyTex[0]->RefCount == 1); /* sanity check */
737   return GL_TRUE;
738}
739
740
741/**
742 * Initialize a texture unit.
743 *
744 * \param ctx GL context.
745 * \param unit texture unit number to be initialized.
746 */
747static void
748init_texture_unit( struct gl_context *ctx, GLuint unit )
749{
750   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
751   GLuint tex;
752
753   texUnit->EnvMode = GL_MODULATE;
754   ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
755
756   texUnit->Combine = default_combine_state;
757   texUnit->_EnvMode = default_combine_state;
758   texUnit->_CurrentCombine = & texUnit->_EnvMode;
759   texUnit->BumpTarget = GL_TEXTURE0;
760
761   texUnit->TexGenEnabled = 0x0;
762   texUnit->GenS.Mode = GL_EYE_LINEAR;
763   texUnit->GenT.Mode = GL_EYE_LINEAR;
764   texUnit->GenR.Mode = GL_EYE_LINEAR;
765   texUnit->GenQ.Mode = GL_EYE_LINEAR;
766   texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;
767   texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;
768   texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;
769   texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;
770
771   /* Yes, these plane coefficients are correct! */
772   ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );
773   ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );
774   ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
775   ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
776   ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );
777   ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );
778   ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );
779   ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );
780
781   /* no mention of this in spec, but maybe id matrix expected? */
782   ASSIGN_4V( texUnit->RotMatrix, 1.0, 0.0, 0.0, 1.0 );
783
784   /* initialize current texture object ptrs to the shared default objects */
785   for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
786      _mesa_reference_texobj(&texUnit->CurrentTex[tex],
787                             ctx->Shared->DefaultTex[tex]);
788   }
789}
790
791
792/**
793 * Initialize texture state for the given context.
794 */
795GLboolean
796_mesa_init_texture(struct gl_context *ctx)
797{
798   GLuint u;
799
800   /* Texture group */
801   ctx->Texture.CurrentUnit = 0;      /* multitexture */
802   ctx->Texture._EnabledUnits = 0x0;
803
804   for (u = 0; u < Elements(ctx->Texture.Unit); u++)
805      init_texture_unit(ctx, u);
806
807   /* After we're done initializing the context's texture state the default
808    * texture objects' refcounts should be at least
809    * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
810    */
811   assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount
812          >= MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1);
813
814   /* Allocate proxy textures */
815   if (!alloc_proxy_textures( ctx ))
816      return GL_FALSE;
817
818   /* GL_ARB_texture_buffer_object */
819   _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject,
820                                 ctx->Shared->NullBufferObj);
821
822   return GL_TRUE;
823}
824
825
826/**
827 * Free dynamically-allocted texture data attached to the given context.
828 */
829void
830_mesa_free_texture_data(struct gl_context *ctx)
831{
832   GLuint u, tgt;
833
834   /* unreference current textures */
835   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
836      /* The _Current texture could account for another reference */
837      _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);
838
839      for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
840         _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);
841      }
842   }
843
844   /* Free proxy texture objects */
845   for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)
846      ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
847
848   /* GL_ARB_texture_buffer_object */
849   _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL);
850
851#if FEATURE_sampler_objects
852   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
853      _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[u].Sampler, NULL);
854   }
855#endif
856}
857
858
859/**
860 * Update the default texture objects in the given context to reference those
861 * specified in the shared state and release those referencing the old
862 * shared state.
863 */
864void
865_mesa_update_default_objects_texture(struct gl_context *ctx)
866{
867   GLuint u, tex;
868
869   for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
870      struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
871      for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
872         _mesa_reference_texobj(&texUnit->CurrentTex[tex],
873                                ctx->Shared->DefaultTex[tex]);
874      }
875   }
876}
877