1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 * OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25 /**
26 * \file texstate.c
27 *
28 * Texture state handling.
29 */
30
31 #include <stdio.h>
32 #include "glheader.h"
33 #include "bufferobj.h"
34 #include "context.h"
35 #include "enums.h"
36 #include "macros.h"
37 #include "texobj.h"
38 #include "teximage.h"
39 #include "texstate.h"
40 #include "mtypes.h"
41 #include "state.h"
42 #include "util/bitscan.h"
43 #include "util/bitset.h"
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 */
51 static 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 */
66 void
_mesa_copy_texture_state(const struct gl_context * src,struct gl_context * dst)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].LodBias = src->Texture.Unit[u].LodBias;
82
83 /*
84 * XXX strictly speaking, we should compare texture names/ids and
85 * bind textures in the dest context according to id. For now, only
86 * copy bindings if the contexts share the same pool of textures to
87 * avoid refcounting bugs.
88 */
89 if (dst->Shared == src->Shared) {
90 /* copy texture object bindings, not contents of texture objects */
91 _mesa_lock_context_textures(dst);
92
93 for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
94 _mesa_reference_texobj(&dst->Texture.Unit[u].CurrentTex[tex],
95 src->Texture.Unit[u].CurrentTex[tex]);
96 if (src->Texture.Unit[u].CurrentTex[tex]) {
97 dst->Texture.NumCurrentTexUsed =
98 MAX2(dst->Texture.NumCurrentTexUsed, u + 1);
99 }
100 }
101 dst->Texture.Unit[u]._BoundTextures = src->Texture.Unit[u]._BoundTextures;
102 _mesa_unlock_context_textures(dst);
103 }
104 }
105
106 for (u = 0; u < src->Const.MaxTextureCoordUnits; u++) {
107 dst->Texture.FixedFuncUnit[u].Enabled = src->Texture.FixedFuncUnit[u].Enabled;
108 dst->Texture.FixedFuncUnit[u].EnvMode = src->Texture.FixedFuncUnit[u].EnvMode;
109 COPY_4V(dst->Texture.FixedFuncUnit[u].EnvColor, src->Texture.FixedFuncUnit[u].EnvColor);
110 dst->Texture.FixedFuncUnit[u].TexGenEnabled = src->Texture.FixedFuncUnit[u].TexGenEnabled;
111 dst->Texture.FixedFuncUnit[u].GenS = src->Texture.FixedFuncUnit[u].GenS;
112 dst->Texture.FixedFuncUnit[u].GenT = src->Texture.FixedFuncUnit[u].GenT;
113 dst->Texture.FixedFuncUnit[u].GenR = src->Texture.FixedFuncUnit[u].GenR;
114 dst->Texture.FixedFuncUnit[u].GenQ = src->Texture.FixedFuncUnit[u].GenQ;
115
116 /* GL_EXT_texture_env_combine */
117 dst->Texture.FixedFuncUnit[u].Combine = src->Texture.FixedFuncUnit[u].Combine;
118 }
119 }
120
121
122 /*
123 * For debugging
124 */
125 void
_mesa_print_texunit_state(struct gl_context * ctx,GLuint unit)126 _mesa_print_texunit_state( struct gl_context *ctx, GLuint unit )
127 {
128 const struct gl_fixedfunc_texture_unit *texUnit = ctx->Texture.FixedFuncUnit + unit;
129 printf("Texture Unit %d\n", unit);
130 printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_enum_to_string(texUnit->EnvMode));
131 printf(" GL_COMBINE_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.ModeRGB));
132 printf(" GL_COMBINE_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.ModeA));
133 printf(" GL_SOURCE0_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[0]));
134 printf(" GL_SOURCE1_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[1]));
135 printf(" GL_SOURCE2_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceRGB[2]));
136 printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[0]));
137 printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[1]));
138 printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.SourceA[2]));
139 printf(" GL_OPERAND0_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[0]));
140 printf(" GL_OPERAND1_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[1]));
141 printf(" GL_OPERAND2_RGB = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandRGB[2]));
142 printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[0]));
143 printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[1]));
144 printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_enum_to_string(texUnit->Combine.OperandA[2]));
145 printf(" GL_RGB_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftRGB);
146 printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit->Combine.ScaleShiftA);
147 printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit->EnvColor[0], texUnit->EnvColor[1], texUnit->EnvColor[2], texUnit->EnvColor[3]);
148 }
149
150
151
152 /**********************************************************************/
153 /* Texture Environment */
154 /**********************************************************************/
155
156 /**
157 * Convert "classic" texture environment to ARB_texture_env_combine style
158 * environments.
159 *
160 * \param state texture_env_combine state vector to be filled-in.
161 * \param mode Classic texture environment mode (i.e., \c GL_REPLACE,
162 * \c GL_BLEND, \c GL_DECAL, etc.).
163 * \param texBaseFormat Base format of the texture associated with the
164 * texture unit.
165 */
166 static void
calculate_derived_texenv(struct gl_tex_env_combine_state * state,GLenum mode,GLenum texBaseFormat)167 calculate_derived_texenv( struct gl_tex_env_combine_state *state,
168 GLenum mode, GLenum texBaseFormat )
169 {
170 GLenum mode_rgb;
171 GLenum mode_a;
172
173 *state = default_combine_state;
174
175 switch (texBaseFormat) {
176 case GL_ALPHA:
177 state->SourceRGB[0] = GL_PREVIOUS;
178 break;
179
180 case GL_LUMINANCE_ALPHA:
181 case GL_INTENSITY:
182 case GL_RGBA:
183 break;
184
185 case GL_LUMINANCE:
186 case GL_RED:
187 case GL_RG:
188 case GL_RGB:
189 case GL_YCBCR_MESA:
190 state->SourceA[0] = GL_PREVIOUS;
191 break;
192
193 default:
194 _mesa_problem(NULL,
195 "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
196 texBaseFormat);
197 return;
198 }
199
200 if (mode == GL_REPLACE_EXT)
201 mode = GL_REPLACE;
202
203 switch (mode) {
204 case GL_REPLACE:
205 case GL_MODULATE:
206 mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : mode;
207 mode_a = mode;
208 break;
209
210 case GL_DECAL:
211 mode_rgb = GL_INTERPOLATE;
212 mode_a = GL_REPLACE;
213
214 state->SourceA[0] = GL_PREVIOUS;
215
216 /* Having alpha / luminance / intensity textures replace using the
217 * incoming fragment color matches the definition in NV_texture_shader.
218 * The 1.5 spec simply marks these as "undefined".
219 */
220 switch (texBaseFormat) {
221 case GL_ALPHA:
222 case GL_LUMINANCE:
223 case GL_LUMINANCE_ALPHA:
224 case GL_INTENSITY:
225 state->SourceRGB[0] = GL_PREVIOUS;
226 break;
227 case GL_RED:
228 case GL_RG:
229 case GL_RGB:
230 case GL_YCBCR_MESA:
231 mode_rgb = GL_REPLACE;
232 break;
233 case GL_RGBA:
234 state->SourceRGB[2] = GL_TEXTURE;
235 break;
236 }
237 break;
238
239 case GL_BLEND:
240 mode_rgb = GL_INTERPOLATE;
241 mode_a = GL_MODULATE;
242
243 switch (texBaseFormat) {
244 case GL_ALPHA:
245 mode_rgb = GL_REPLACE;
246 break;
247 case GL_INTENSITY:
248 mode_a = GL_INTERPOLATE;
249 state->SourceA[0] = GL_CONSTANT;
250 state->OperandA[2] = GL_SRC_ALPHA;
251 /* FALLTHROUGH */
252 case GL_LUMINANCE:
253 case GL_RED:
254 case GL_RG:
255 case GL_RGB:
256 case GL_LUMINANCE_ALPHA:
257 case GL_RGBA:
258 case GL_YCBCR_MESA:
259 state->SourceRGB[2] = GL_TEXTURE;
260 state->SourceA[2] = GL_TEXTURE;
261 state->SourceRGB[0] = GL_CONSTANT;
262 state->OperandRGB[2] = GL_SRC_COLOR;
263 break;
264 }
265 break;
266
267 case GL_ADD:
268 mode_rgb = (texBaseFormat == GL_ALPHA) ? GL_REPLACE : GL_ADD;
269 mode_a = (texBaseFormat == GL_INTENSITY) ? GL_ADD : GL_MODULATE;
270 break;
271
272 default:
273 _mesa_problem(NULL,
274 "Invalid texture env mode 0x%x in calculate_derived_texenv",
275 mode);
276 return;
277 }
278
279 state->ModeRGB = (state->SourceRGB[0] != GL_PREVIOUS)
280 ? mode_rgb : GL_REPLACE;
281 state->ModeA = (state->SourceA[0] != GL_PREVIOUS)
282 ? mode_a : GL_REPLACE;
283 }
284
285
286 /* GL_ARB_multitexture */
287 static ALWAYS_INLINE void
active_texture(GLenum texture,bool no_error)288 active_texture(GLenum texture, bool no_error)
289 {
290 const GLuint texUnit = texture - GL_TEXTURE0;
291
292 GET_CURRENT_CONTEXT(ctx);
293
294 if (MESA_VERBOSE & (VERBOSE_API|VERBOSE_TEXTURE))
295 _mesa_debug(ctx, "glActiveTexture %s\n",
296 _mesa_enum_to_string(texture));
297
298 if (ctx->Texture.CurrentUnit == texUnit)
299 return;
300
301 if (!no_error) {
302 GLuint k = _mesa_max_tex_unit(ctx);
303
304 assert(k <= ARRAY_SIZE(ctx->Texture.Unit));
305
306 if (texUnit >= k) {
307 _mesa_error(ctx, GL_INVALID_ENUM, "glActiveTexture(texture=%s)",
308 _mesa_enum_to_string(texture));
309 return;
310 }
311 }
312
313
314 /* The below flush call seems useless because
315 * gl_context::Texture::CurrentUnit is not used by
316 * _mesa_update_texture_state() and friends.
317 *
318 * However removing the flush
319 * introduced some blinking textures in UT2004. More investigation is
320 * needed to find the root cause.
321 *
322 * https://bugs.freedesktop.org/show_bug.cgi?id=105436
323 */
324 FLUSH_VERTICES(ctx, _NEW_TEXTURE_STATE);
325
326 ctx->Texture.CurrentUnit = texUnit;
327 if (ctx->Transform.MatrixMode == GL_TEXTURE) {
328 /* update current stack pointer */
329 ctx->CurrentStack = &ctx->TextureMatrixStack[texUnit];
330 }
331 }
332
333
334 void GLAPIENTRY
_mesa_ActiveTexture_no_error(GLenum texture)335 _mesa_ActiveTexture_no_error(GLenum texture)
336 {
337 active_texture(texture, true);
338 }
339
340
341 void GLAPIENTRY
_mesa_ActiveTexture(GLenum texture)342 _mesa_ActiveTexture(GLenum texture)
343 {
344 active_texture(texture, false);
345 }
346
347
348 /* GL_ARB_multitexture */
349 void GLAPIENTRY
_mesa_ClientActiveTexture(GLenum texture)350 _mesa_ClientActiveTexture(GLenum texture)
351 {
352 GET_CURRENT_CONTEXT(ctx);
353 GLuint texUnit = texture - GL_TEXTURE0;
354
355 if (MESA_VERBOSE & (VERBOSE_API | VERBOSE_TEXTURE))
356 _mesa_debug(ctx, "glClientActiveTexture %s\n",
357 _mesa_enum_to_string(texture));
358
359 if (ctx->Array.ActiveTexture == texUnit)
360 return;
361
362 if (texUnit >= ctx->Const.MaxTextureCoordUnits) {
363 _mesa_error(ctx, GL_INVALID_ENUM, "glClientActiveTexture(texture=%s)",
364 _mesa_enum_to_string(texture));
365 return;
366 }
367
368 /* Don't flush vertices. This is a "latched" state. */
369 ctx->Array.ActiveTexture = texUnit;
370 }
371
372
373
374 /**********************************************************************/
375 /***** State management *****/
376 /**********************************************************************/
377
378
379 /**
380 * \note This routine refers to derived texture attribute values to
381 * compute the ENABLE_TEXMAT flags, but is only called on
382 * _NEW_TEXTURE_MATRIX. On changes to _NEW_TEXTURE_OBJECT/STATE,
383 * the ENABLE_TEXMAT flags are updated by _mesa_update_textures(), below.
384 *
385 * \param ctx GL context.
386 */
387 void
_mesa_update_texture_matrices(struct gl_context * ctx)388 _mesa_update_texture_matrices(struct gl_context *ctx)
389 {
390 GLuint u;
391
392 ctx->Texture._TexMatEnabled = 0x0;
393
394 for (u = 0; u < ctx->Const.MaxTextureCoordUnits; u++) {
395 assert(u < ARRAY_SIZE(ctx->TextureMatrixStack));
396 if (_math_matrix_is_dirty(ctx->TextureMatrixStack[u].Top)) {
397 _math_matrix_analyse( ctx->TextureMatrixStack[u].Top );
398
399 if (ctx->Texture.Unit[u]._Current &&
400 ctx->TextureMatrixStack[u].Top->type != MATRIX_IDENTITY)
401 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(u);
402 }
403 }
404 }
405
406
407 /**
408 * Translate GL combiner state into a MODE_x value
409 */
410 static uint32_t
tex_combine_translate_mode(GLenum envMode,GLenum mode)411 tex_combine_translate_mode(GLenum envMode, GLenum mode)
412 {
413 switch (mode) {
414 case GL_REPLACE: return TEXENV_MODE_REPLACE;
415 case GL_MODULATE: return TEXENV_MODE_MODULATE;
416 case GL_ADD:
417 if (envMode == GL_COMBINE4_NV)
418 return TEXENV_MODE_ADD_PRODUCTS_NV;
419 else
420 return TEXENV_MODE_ADD;
421 case GL_ADD_SIGNED:
422 if (envMode == GL_COMBINE4_NV)
423 return TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV;
424 else
425 return TEXENV_MODE_ADD_SIGNED;
426 case GL_INTERPOLATE: return TEXENV_MODE_INTERPOLATE;
427 case GL_SUBTRACT: return TEXENV_MODE_SUBTRACT;
428 case GL_DOT3_RGB: return TEXENV_MODE_DOT3_RGB;
429 case GL_DOT3_RGB_EXT: return TEXENV_MODE_DOT3_RGB_EXT;
430 case GL_DOT3_RGBA: return TEXENV_MODE_DOT3_RGBA;
431 case GL_DOT3_RGBA_EXT: return TEXENV_MODE_DOT3_RGBA_EXT;
432 case GL_MODULATE_ADD_ATI: return TEXENV_MODE_MODULATE_ADD_ATI;
433 case GL_MODULATE_SIGNED_ADD_ATI: return TEXENV_MODE_MODULATE_SIGNED_ADD_ATI;
434 case GL_MODULATE_SUBTRACT_ATI: return TEXENV_MODE_MODULATE_SUBTRACT_ATI;
435 default:
436 unreachable("Invalid TexEnv Combine mode");
437 }
438 }
439
440
441 static uint8_t
tex_combine_translate_source(GLenum src)442 tex_combine_translate_source(GLenum src)
443 {
444 switch (src) {
445 case GL_TEXTURE0:
446 case GL_TEXTURE1:
447 case GL_TEXTURE2:
448 case GL_TEXTURE3:
449 case GL_TEXTURE4:
450 case GL_TEXTURE5:
451 case GL_TEXTURE6:
452 case GL_TEXTURE7: return TEXENV_SRC_TEXTURE0 + (src - GL_TEXTURE0);
453 case GL_TEXTURE: return TEXENV_SRC_TEXTURE;
454 case GL_PREVIOUS: return TEXENV_SRC_PREVIOUS;
455 case GL_PRIMARY_COLOR: return TEXENV_SRC_PRIMARY_COLOR;
456 case GL_CONSTANT: return TEXENV_SRC_CONSTANT;
457 case GL_ZERO: return TEXENV_SRC_ZERO;
458 case GL_ONE: return TEXENV_SRC_ONE;
459 default:
460 unreachable("Invalid TexEnv Combine argument source");
461 }
462 }
463
464
465 static uint8_t
tex_combine_translate_operand(GLenum operand)466 tex_combine_translate_operand(GLenum operand)
467 {
468 switch (operand) {
469 case GL_SRC_COLOR: return TEXENV_OPR_COLOR;
470 case GL_ONE_MINUS_SRC_COLOR: return TEXENV_OPR_ONE_MINUS_COLOR;
471 case GL_SRC_ALPHA: return TEXENV_OPR_ALPHA;
472 case GL_ONE_MINUS_SRC_ALPHA: return TEXENV_OPR_ONE_MINUS_ALPHA;
473 default:
474 unreachable("Invalid TexEnv Combine argument source");
475 }
476 }
477
478
479 static void
pack_tex_combine(struct gl_fixedfunc_texture_unit * texUnit)480 pack_tex_combine(struct gl_fixedfunc_texture_unit *texUnit)
481 {
482 struct gl_tex_env_combine_state *state = texUnit->_CurrentCombine;
483 struct gl_tex_env_combine_packed *packed = &texUnit->_CurrentCombinePacked;
484
485 memset(packed, 0, sizeof *packed);
486
487 packed->ModeRGB = tex_combine_translate_mode(texUnit->EnvMode, state->ModeRGB);
488 packed->ModeA = tex_combine_translate_mode(texUnit->EnvMode, state->ModeA);
489 packed->ScaleShiftRGB = state->ScaleShiftRGB;
490 packed->ScaleShiftA = state->ScaleShiftA;
491 packed->NumArgsRGB = state->_NumArgsRGB;
492 packed->NumArgsA = state->_NumArgsA;
493
494 for (int i = 0; i < state->_NumArgsRGB; ++i)
495 {
496 packed->ArgsRGB[i].Source = tex_combine_translate_source(state->SourceRGB[i]);
497 packed->ArgsRGB[i].Operand = tex_combine_translate_operand(state->OperandRGB[i]);
498 }
499
500 for (int i = 0; i < state->_NumArgsA; ++i)
501 {
502 packed->ArgsA[i].Source = tex_combine_translate_source(state->SourceA[i]);
503 packed->ArgsA[i].Operand = tex_combine_translate_operand(state->OperandA[i]);
504 }
505 }
506
507
508 /**
509 * Examine texture unit's combine/env state to update derived state.
510 */
511 static void
update_tex_combine(struct gl_context * ctx,struct gl_texture_unit * texUnit,struct gl_fixedfunc_texture_unit * fftexUnit)512 update_tex_combine(struct gl_context *ctx,
513 struct gl_texture_unit *texUnit,
514 struct gl_fixedfunc_texture_unit *fftexUnit)
515 {
516 struct gl_tex_env_combine_state *combine;
517
518 /* No combiners will apply to this. */
519 if (texUnit->_Current->Target == GL_TEXTURE_BUFFER)
520 return;
521
522 /* Set the texUnit->_CurrentCombine field to point to the user's combiner
523 * state, or the combiner state which is derived from traditional texenv
524 * mode.
525 */
526 if (fftexUnit->EnvMode == GL_COMBINE ||
527 fftexUnit->EnvMode == GL_COMBINE4_NV) {
528 fftexUnit->_CurrentCombine = & fftexUnit->Combine;
529 }
530 else {
531 const struct gl_texture_object *texObj = texUnit->_Current;
532 GLenum format = texObj->Image[0][texObj->BaseLevel]->_BaseFormat;
533
534 if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL_EXT) {
535 format = texObj->DepthMode;
536 }
537 calculate_derived_texenv(&fftexUnit->_EnvMode, fftexUnit->EnvMode, format);
538 fftexUnit->_CurrentCombine = & fftexUnit->_EnvMode;
539 }
540
541 combine = fftexUnit->_CurrentCombine;
542
543 /* Determine number of source RGB terms in the combiner function */
544 switch (combine->ModeRGB) {
545 case GL_REPLACE:
546 combine->_NumArgsRGB = 1;
547 break;
548 case GL_ADD:
549 case GL_ADD_SIGNED:
550 if (fftexUnit->EnvMode == GL_COMBINE4_NV)
551 combine->_NumArgsRGB = 4;
552 else
553 combine->_NumArgsRGB = 2;
554 break;
555 case GL_MODULATE:
556 case GL_SUBTRACT:
557 case GL_DOT3_RGB:
558 case GL_DOT3_RGBA:
559 case GL_DOT3_RGB_EXT:
560 case GL_DOT3_RGBA_EXT:
561 combine->_NumArgsRGB = 2;
562 break;
563 case GL_INTERPOLATE:
564 case GL_MODULATE_ADD_ATI:
565 case GL_MODULATE_SIGNED_ADD_ATI:
566 case GL_MODULATE_SUBTRACT_ATI:
567 combine->_NumArgsRGB = 3;
568 break;
569 default:
570 combine->_NumArgsRGB = 0;
571 _mesa_problem(ctx, "invalid RGB combine mode in update_texture_state");
572 return;
573 }
574
575 /* Determine number of source Alpha terms in the combiner function */
576 switch (combine->ModeA) {
577 case GL_REPLACE:
578 combine->_NumArgsA = 1;
579 break;
580 case GL_ADD:
581 case GL_ADD_SIGNED:
582 if (fftexUnit->EnvMode == GL_COMBINE4_NV)
583 combine->_NumArgsA = 4;
584 else
585 combine->_NumArgsA = 2;
586 break;
587 case GL_MODULATE:
588 case GL_SUBTRACT:
589 combine->_NumArgsA = 2;
590 break;
591 case GL_INTERPOLATE:
592 case GL_MODULATE_ADD_ATI:
593 case GL_MODULATE_SIGNED_ADD_ATI:
594 case GL_MODULATE_SUBTRACT_ATI:
595 combine->_NumArgsA = 3;
596 break;
597 default:
598 combine->_NumArgsA = 0;
599 _mesa_problem(ctx, "invalid Alpha combine mode in update_texture_state");
600 break;
601 }
602
603 pack_tex_combine(fftexUnit);
604 }
605
606 static void
update_texgen(struct gl_context * ctx)607 update_texgen(struct gl_context *ctx)
608 {
609 GLuint unit;
610
611 /* Setup texgen for those texture coordinate sets that are in use */
612 for (unit = 0; unit < ctx->Const.MaxTextureCoordUnits; unit++) {
613 struct gl_fixedfunc_texture_unit *texUnit =
614 &ctx->Texture.FixedFuncUnit[unit];
615
616 texUnit->_GenFlags = 0x0;
617
618 if (!(ctx->Texture._EnabledCoordUnits & (1 << unit)))
619 continue;
620
621 if (texUnit->TexGenEnabled) {
622 if (texUnit->TexGenEnabled & S_BIT) {
623 texUnit->_GenFlags |= texUnit->GenS._ModeBit;
624 }
625 if (texUnit->TexGenEnabled & T_BIT) {
626 texUnit->_GenFlags |= texUnit->GenT._ModeBit;
627 }
628 if (texUnit->TexGenEnabled & R_BIT) {
629 texUnit->_GenFlags |= texUnit->GenR._ModeBit;
630 }
631 if (texUnit->TexGenEnabled & Q_BIT) {
632 texUnit->_GenFlags |= texUnit->GenQ._ModeBit;
633 }
634
635 ctx->Texture._TexGenEnabled |= ENABLE_TEXGEN(unit);
636 ctx->Texture._GenFlags |= texUnit->_GenFlags;
637 }
638
639 assert(unit < ARRAY_SIZE(ctx->TextureMatrixStack));
640 if (ctx->TextureMatrixStack[unit].Top->type != MATRIX_IDENTITY)
641 ctx->Texture._TexMatEnabled |= ENABLE_TEXMAT(unit);
642 }
643 }
644
645 static struct gl_texture_object *
update_single_program_texture(struct gl_context * ctx,struct gl_program * prog,int unit)646 update_single_program_texture(struct gl_context *ctx, struct gl_program *prog,
647 int unit)
648 {
649 gl_texture_index target_index;
650 struct gl_texture_unit *texUnit;
651 struct gl_texture_object *texObj;
652 struct gl_sampler_object *sampler;
653
654 texUnit = &ctx->Texture.Unit[unit];
655
656 /* Note: If more than one bit was set in TexturesUsed[unit], then we should
657 * have had the draw call rejected already. From the GL 4.4 specification,
658 * section 7.10 ("Samplers"):
659 *
660 * "It is not allowed to have variables of different sampler types
661 * pointing to the same texture image unit within a program
662 * object. This situation can only be detected at the next rendering
663 * command issued which triggers shader invocations, and an
664 * INVALID_OPERATION error will then be generated."
665 */
666 target_index = ffs(prog->TexturesUsed[unit]) - 1;
667 texObj = texUnit->CurrentTex[target_index];
668
669 sampler = texUnit->Sampler ?
670 texUnit->Sampler : &texObj->Sampler;
671
672 if (likely(texObj)) {
673 if (_mesa_is_texture_complete(texObj, sampler,
674 ctx->Const.ForceIntegerTexNearest))
675 return texObj;
676
677 _mesa_test_texobj_completeness(ctx, texObj);
678 if (_mesa_is_texture_complete(texObj, sampler,
679 ctx->Const.ForceIntegerTexNearest))
680 return texObj;
681 }
682
683 /* If we've reached this point, we didn't find a complete texture of the
684 * shader's target. From the GL 4.4 core specification, section 11.1.3.5
685 * ("Texture Access"):
686 *
687 * "If a sampler is used in a shader and the sampler’s associated
688 * texture is not complete, as defined in section 8.17, (0, 0, 0, 1)
689 * will be returned for a non-shadow sampler and 0 for a shadow
690 * sampler."
691 *
692 * Mesa implements this by creating a hidden texture object with a pixel of
693 * that value.
694 */
695 texObj = _mesa_get_fallback_texture(ctx, target_index);
696 assert(texObj);
697
698 return texObj;
699 }
700
701 static inline void
update_single_program_texture_state(struct gl_context * ctx,struct gl_program * prog,int unit,BITSET_WORD * enabled_texture_units)702 update_single_program_texture_state(struct gl_context *ctx,
703 struct gl_program *prog,
704 int unit,
705 BITSET_WORD *enabled_texture_units)
706 {
707 struct gl_texture_object *texObj;
708
709 texObj = update_single_program_texture(ctx, prog, unit);
710
711 _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj);
712 BITSET_SET(enabled_texture_units, unit);
713 ctx->Texture._MaxEnabledTexImageUnit =
714 MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit);
715 }
716
717 static void
update_program_texture_state(struct gl_context * ctx,struct gl_program ** prog,BITSET_WORD * enabled_texture_units)718 update_program_texture_state(struct gl_context *ctx, struct gl_program **prog,
719 BITSET_WORD *enabled_texture_units)
720 {
721 int i;
722
723 for (i = 0; i < MESA_SHADER_STAGES; i++) {
724 GLbitfield mask;
725 GLuint s;
726
727 if (!prog[i])
728 continue;
729
730 mask = prog[i]->SamplersUsed;
731
732 while (mask) {
733 s = u_bit_scan(&mask);
734
735 update_single_program_texture_state(ctx, prog[i],
736 prog[i]->SamplerUnits[s],
737 enabled_texture_units);
738 }
739
740 if (unlikely(prog[i]->sh.HasBoundBindlessSampler)) {
741 /* Loop over bindless samplers bound to texture units.
742 */
743 for (s = 0; s < prog[i]->sh.NumBindlessSamplers; s++) {
744 struct gl_bindless_sampler *sampler =
745 &prog[i]->sh.BindlessSamplers[s];
746
747 if (!sampler->bound)
748 continue;
749
750 update_single_program_texture_state(ctx, prog[i], sampler->unit,
751 enabled_texture_units);
752 }
753 }
754 }
755
756 if (prog[MESA_SHADER_FRAGMENT]) {
757 const GLuint coordMask = (1 << MAX_TEXTURE_COORD_UNITS) - 1;
758 ctx->Texture._EnabledCoordUnits |=
759 (prog[MESA_SHADER_FRAGMENT]->info.inputs_read >> VARYING_SLOT_TEX0) &
760 coordMask;
761 }
762 }
763
764 static void
update_ff_texture_state(struct gl_context * ctx,BITSET_WORD * enabled_texture_units)765 update_ff_texture_state(struct gl_context *ctx,
766 BITSET_WORD *enabled_texture_units)
767 {
768 int unit;
769
770 for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
771 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
772 struct gl_fixedfunc_texture_unit *fftexUnit =
773 &ctx->Texture.FixedFuncUnit[unit];
774 GLbitfield mask;
775 bool complete;
776
777 if (fftexUnit->Enabled == 0x0)
778 continue;
779
780 /* If a shader already dictated what texture target was used for this
781 * unit, just go along with it.
782 */
783 if (BITSET_TEST(enabled_texture_units, unit))
784 continue;
785
786 /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"):
787 *
788 * "Texturing is enabled or disabled using the generic Enable and
789 * Disable commands, respectively, with the symbolic constants
790 * TEXTURE_1D, TEXTURE_2D, TEXTURE_RECTANGLE, TEXTURE_3D, or
791 * TEXTURE_CUBE_MAP to enable the one-, two-, rectangular,
792 * three-dimensional, or cube map texture, respectively. If more
793 * than one of these textures is enabled, the first one enabled
794 * from the following list is used:
795 *
796 * • cube map texture
797 * • three-dimensional texture
798 * • rectangular texture
799 * • two-dimensional texture
800 * • one-dimensional texture"
801 *
802 * Note that the TEXTURE_x_INDEX values are in high to low priority.
803 * Also:
804 *
805 * "If a texture unit is disabled or has an invalid or incomplete
806 * texture (as defined in section 8.17) bound to it, then blending
807 * is disabled for that texture unit. If the texture environment
808 * for a given enabled texture unit references a disabled texture
809 * unit, or an invalid or incomplete texture that is bound to
810 * another unit, then the results of texture blending are
811 * undefined."
812 */
813 complete = false;
814 mask = fftexUnit->Enabled;
815 while (mask) {
816 const int texIndex = u_bit_scan(&mask);
817 struct gl_texture_object *texObj = texUnit->CurrentTex[texIndex];
818 struct gl_sampler_object *sampler = texUnit->Sampler ?
819 texUnit->Sampler : &texObj->Sampler;
820
821 if (!_mesa_is_texture_complete(texObj, sampler,
822 ctx->Const.ForceIntegerTexNearest)) {
823 _mesa_test_texobj_completeness(ctx, texObj);
824 }
825 if (_mesa_is_texture_complete(texObj, sampler,
826 ctx->Const.ForceIntegerTexNearest)) {
827 _mesa_reference_texobj(&texUnit->_Current, texObj);
828 complete = true;
829 break;
830 }
831 }
832
833 if (!complete)
834 continue;
835
836 /* if we get here, we know this texture unit is enabled */
837 BITSET_SET(enabled_texture_units, unit);
838 ctx->Texture._MaxEnabledTexImageUnit =
839 MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit);
840
841 ctx->Texture._EnabledCoordUnits |= 1 << unit;
842
843 update_tex_combine(ctx, texUnit, fftexUnit);
844 }
845 }
846
847 static void
fix_missing_textures_for_atifs(struct gl_context * ctx,struct gl_program * prog,BITSET_WORD * enabled_texture_units)848 fix_missing_textures_for_atifs(struct gl_context *ctx,
849 struct gl_program *prog,
850 BITSET_WORD *enabled_texture_units)
851 {
852 GLbitfield mask = prog->SamplersUsed;
853
854 while (mask) {
855 const int s = u_bit_scan(&mask);
856 const int unit = prog->SamplerUnits[s];
857 const gl_texture_index target_index = ffs(prog->TexturesUsed[unit]) - 1;
858
859 if (!ctx->Texture.Unit[unit]._Current) {
860 struct gl_texture_object *texObj =
861 _mesa_get_fallback_texture(ctx, target_index);
862 _mesa_reference_texobj(&ctx->Texture.Unit[unit]._Current, texObj);
863 BITSET_SET(enabled_texture_units, unit);
864 ctx->Texture._MaxEnabledTexImageUnit =
865 MAX2(ctx->Texture._MaxEnabledTexImageUnit, (int)unit);
866 }
867 }
868 }
869
870 /**
871 * \note This routine refers to derived texture matrix values to
872 * compute the ENABLE_TEXMAT flags, but is only called on
873 * _NEW_TEXTURE_OBJECT/STATE. On changes to _NEW_TEXTURE_MATRIX,
874 * the ENABLE_TEXMAT flags are updated by _mesa_update_texture_matrices,
875 * above.
876 *
877 * \param ctx GL context.
878 */
879 void
_mesa_update_texture_state(struct gl_context * ctx)880 _mesa_update_texture_state(struct gl_context *ctx)
881 {
882 struct gl_program *prog[MESA_SHADER_STAGES];
883 int i;
884 int old_max_unit = ctx->Texture._MaxEnabledTexImageUnit;
885 BITSET_DECLARE(enabled_texture_units, MAX_COMBINED_TEXTURE_IMAGE_UNITS);
886
887 memcpy(prog, ctx->_Shader->CurrentProgram, sizeof(prog));
888
889 if (prog[MESA_SHADER_FRAGMENT] == NULL &&
890 _mesa_arb_fragment_program_enabled(ctx)) {
891 prog[MESA_SHADER_FRAGMENT] = ctx->FragmentProgram.Current;
892 }
893
894 /* TODO: only set this if there are actual changes */
895 ctx->NewState |= _NEW_TEXTURE_OBJECT | _NEW_TEXTURE_STATE;
896
897 ctx->Texture._GenFlags = 0x0;
898 ctx->Texture._TexMatEnabled = 0x0;
899 ctx->Texture._TexGenEnabled = 0x0;
900 ctx->Texture._MaxEnabledTexImageUnit = -1;
901 ctx->Texture._EnabledCoordUnits = 0x0;
902
903 memset(&enabled_texture_units, 0, sizeof(enabled_texture_units));
904
905 /* First, walk over our programs pulling in all the textures for them.
906 * Programs dictate specific texture targets to be enabled, and for a draw
907 * call to be valid they can't conflict about which texture targets are
908 * used.
909 */
910 update_program_texture_state(ctx, prog, enabled_texture_units);
911
912 /* Also pull in any textures necessary for fixed function fragment shading.
913 */
914 if (!prog[MESA_SHADER_FRAGMENT])
915 update_ff_texture_state(ctx, enabled_texture_units);
916
917 /* Now, clear out the _Current of any disabled texture units. */
918 for (i = 0; i <= ctx->Texture._MaxEnabledTexImageUnit; i++) {
919 if (!BITSET_TEST(enabled_texture_units, i))
920 _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL);
921 }
922 for (i = ctx->Texture._MaxEnabledTexImageUnit + 1; i <= old_max_unit; i++) {
923 _mesa_reference_texobj(&ctx->Texture.Unit[i]._Current, NULL);
924 }
925
926 /* add fallback texture for SampleMapATI if there is nothing */
927 if (_mesa_ati_fragment_shader_enabled(ctx) &&
928 ctx->ATIFragmentShader.Current->Program)
929 fix_missing_textures_for_atifs(ctx,
930 ctx->ATIFragmentShader.Current->Program,
931 enabled_texture_units);
932
933 if (!prog[MESA_SHADER_FRAGMENT] || !prog[MESA_SHADER_VERTEX])
934 update_texgen(ctx);
935 }
936
937
938 /**********************************************************************/
939 /***** Initialization *****/
940 /**********************************************************************/
941
942 /**
943 * Allocate the proxy textures for the given context.
944 *
945 * \param ctx the context to allocate proxies for.
946 *
947 * \return GL_TRUE on success, or GL_FALSE on failure
948 *
949 * If run out of memory part way through the allocations, clean up and return
950 * GL_FALSE.
951 */
952 static GLboolean
alloc_proxy_textures(struct gl_context * ctx)953 alloc_proxy_textures( struct gl_context *ctx )
954 {
955 /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
956 * values!
957 */
958 static const GLenum targets[] = {
959 GL_TEXTURE_2D_MULTISAMPLE,
960 GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
961 GL_TEXTURE_CUBE_MAP_ARRAY,
962 GL_TEXTURE_BUFFER,
963 GL_TEXTURE_2D_ARRAY_EXT,
964 GL_TEXTURE_1D_ARRAY_EXT,
965 GL_TEXTURE_EXTERNAL_OES,
966 GL_TEXTURE_CUBE_MAP,
967 GL_TEXTURE_3D,
968 GL_TEXTURE_RECTANGLE_NV,
969 GL_TEXTURE_2D,
970 GL_TEXTURE_1D,
971 };
972 GLint tgt;
973
974 STATIC_ASSERT(ARRAY_SIZE(targets) == NUM_TEXTURE_TARGETS);
975 assert(targets[TEXTURE_2D_INDEX] == GL_TEXTURE_2D);
976 assert(targets[TEXTURE_CUBE_INDEX] == GL_TEXTURE_CUBE_MAP);
977
978 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
979 if (!(ctx->Texture.ProxyTex[tgt]
980 = ctx->Driver.NewTextureObject(ctx, 0, targets[tgt]))) {
981 /* out of memory, free what we did allocate */
982 while (--tgt >= 0) {
983 ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
984 }
985 return GL_FALSE;
986 }
987 }
988
989 assert(ctx->Texture.ProxyTex[0]->RefCount == 1); /* sanity check */
990 return GL_TRUE;
991 }
992
993
994 /**
995 * Initialize texture state for the given context.
996 */
997 GLboolean
_mesa_init_texture(struct gl_context * ctx)998 _mesa_init_texture(struct gl_context *ctx)
999 {
1000 GLuint u;
1001
1002 /* Texture group */
1003 ctx->Texture.CurrentUnit = 0; /* multitexture */
1004
1005 /* Appendix F.2 of the OpenGL ES 3.0 spec says:
1006 *
1007 * "OpenGL ES 3.0 requires that all cube map filtering be
1008 * seamless. OpenGL ES 2.0 specified that a single cube map face be
1009 * selected and used for filtering."
1010 *
1011 * Unfortunatley, a call to _mesa_is_gles3 below will only work if
1012 * the driver has already computed and set ctx->Version, however drivers
1013 * seem to call _mesa_initialize_context (which calls this) early
1014 * in the CreateContext hook and _mesa_compute_version much later (since
1015 * it needs information about available extensions). So, we will
1016 * enable seamless cubemaps by default since GLES2. This should work
1017 * for most implementations and drivers that don't support seamless
1018 * cubemaps for GLES2 can still disable it.
1019 */
1020 ctx->Texture.CubeMapSeamless = ctx->API == API_OPENGLES2;
1021
1022 for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
1023 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
1024 GLuint tex;
1025
1026 /* initialize current texture object ptrs to the shared default objects */
1027 for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
1028 _mesa_reference_texobj(&texUnit->CurrentTex[tex],
1029 ctx->Shared->DefaultTex[tex]);
1030 }
1031
1032 texUnit->_BoundTextures = 0;
1033 }
1034
1035 for (u = 0; u < ARRAY_SIZE(ctx->Texture.FixedFuncUnit); u++) {
1036 struct gl_fixedfunc_texture_unit *texUnit =
1037 &ctx->Texture.FixedFuncUnit[u];
1038
1039 texUnit->EnvMode = GL_MODULATE;
1040 ASSIGN_4V( texUnit->EnvColor, 0.0, 0.0, 0.0, 0.0 );
1041
1042 texUnit->Combine = default_combine_state;
1043 texUnit->_EnvMode = default_combine_state;
1044 texUnit->_CurrentCombine = & texUnit->_EnvMode;
1045
1046 texUnit->TexGenEnabled = 0x0;
1047 texUnit->GenS.Mode = GL_EYE_LINEAR;
1048 texUnit->GenT.Mode = GL_EYE_LINEAR;
1049 texUnit->GenR.Mode = GL_EYE_LINEAR;
1050 texUnit->GenQ.Mode = GL_EYE_LINEAR;
1051 texUnit->GenS._ModeBit = TEXGEN_EYE_LINEAR;
1052 texUnit->GenT._ModeBit = TEXGEN_EYE_LINEAR;
1053 texUnit->GenR._ModeBit = TEXGEN_EYE_LINEAR;
1054 texUnit->GenQ._ModeBit = TEXGEN_EYE_LINEAR;
1055
1056 /* Yes, these plane coefficients are correct! */
1057 ASSIGN_4V( texUnit->GenS.ObjectPlane, 1.0, 0.0, 0.0, 0.0 );
1058 ASSIGN_4V( texUnit->GenT.ObjectPlane, 0.0, 1.0, 0.0, 0.0 );
1059 ASSIGN_4V( texUnit->GenR.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
1060 ASSIGN_4V( texUnit->GenQ.ObjectPlane, 0.0, 0.0, 0.0, 0.0 );
1061 ASSIGN_4V( texUnit->GenS.EyePlane, 1.0, 0.0, 0.0, 0.0 );
1062 ASSIGN_4V( texUnit->GenT.EyePlane, 0.0, 1.0, 0.0, 0.0 );
1063 ASSIGN_4V( texUnit->GenR.EyePlane, 0.0, 0.0, 0.0, 0.0 );
1064 ASSIGN_4V( texUnit->GenQ.EyePlane, 0.0, 0.0, 0.0, 0.0 );
1065 }
1066
1067 /* After we're done initializing the context's texture state the default
1068 * texture objects' refcounts should be at least
1069 * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
1070 */
1071 assert(ctx->Shared->DefaultTex[TEXTURE_1D_INDEX]->RefCount
1072 >= MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1);
1073
1074 /* Allocate proxy textures */
1075 if (!alloc_proxy_textures( ctx ))
1076 return GL_FALSE;
1077
1078 /* GL_ARB_texture_buffer_object */
1079 _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL);
1080
1081 ctx->Texture.NumCurrentTexUsed = 0;
1082
1083 return GL_TRUE;
1084 }
1085
1086
1087 /**
1088 * Free dynamically-allocted texture data attached to the given context.
1089 */
1090 void
_mesa_free_texture_data(struct gl_context * ctx)1091 _mesa_free_texture_data(struct gl_context *ctx)
1092 {
1093 GLuint u, tgt;
1094
1095 /* unreference current textures */
1096 for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
1097 /* The _Current texture could account for another reference */
1098 _mesa_reference_texobj(&ctx->Texture.Unit[u]._Current, NULL);
1099
1100 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
1101 _mesa_reference_texobj(&ctx->Texture.Unit[u].CurrentTex[tgt], NULL);
1102 }
1103 }
1104
1105 /* Free proxy texture objects */
1106 for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++)
1107 ctx->Driver.DeleteTexture(ctx, ctx->Texture.ProxyTex[tgt]);
1108
1109 /* GL_ARB_texture_buffer_object */
1110 _mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL);
1111
1112 for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
1113 _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[u].Sampler, NULL);
1114 }
1115 }
1116
1117
1118 /**
1119 * Update the default texture objects in the given context to reference those
1120 * specified in the shared state and release those referencing the old
1121 * shared state.
1122 */
1123 void
_mesa_update_default_objects_texture(struct gl_context * ctx)1124 _mesa_update_default_objects_texture(struct gl_context *ctx)
1125 {
1126 GLuint u, tex;
1127
1128 for (u = 0; u < ARRAY_SIZE(ctx->Texture.Unit); u++) {
1129 struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
1130 for (tex = 0; tex < NUM_TEXTURE_TARGETS; tex++) {
1131 _mesa_reference_texobj(&texUnit->CurrentTex[tex],
1132 ctx->Shared->DefaultTex[tex]);
1133 }
1134 }
1135 }
1136