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