2 * Mesa 3-D graphics library
4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
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:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
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.
28 * Texture state handling.
33 #include "bufferobj.h"
42 #include "util/bitscan.h"
43 #include "util/bitset.h"
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.
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
},
64 * Used by glXCopyContext to copy texture state from one context to another.
67 _mesa_copy_texture_state( const struct gl_context
*src
, struct gl_context
*dst
)
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
;
80 for (u
= 0; u
< src
->Const
.MaxCombinedTextureImageUnits
; u
++) {
81 dst
->Texture
.Unit
[u
].LodBias
= src
->Texture
.Unit
[u
].LodBias
;
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.
89 if (dst
->Shared
== src
->Shared
) {
90 /* copy texture object bindings, not contents of texture objects */
91 _mesa_lock_context_textures(dst
);
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);
101 dst
->Texture
.Unit
[u
]._BoundTextures
= src
->Texture
.Unit
[u
]._BoundTextures
;
102 _mesa_unlock_context_textures(dst
);
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
;
116 /* GL_EXT_texture_env_combine */
117 dst
->Texture
.FixedFuncUnit
[u
].Combine
= src
->Texture
.FixedFuncUnit
[u
].Combine
;
126 _mesa_print_texunit_state( struct gl_context
*ctx
, GLuint unit
)
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]);
152 /**********************************************************************/
153 /* Texture Environment */
154 /**********************************************************************/
157 * Convert "classic" texture environment to ARB_texture_env_combine style
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
167 calculate_derived_texenv( struct gl_tex_env_combine_state
*state
,
168 GLenum mode
, GLenum texBaseFormat
)
173 *state
= default_combine_state
;
175 switch (texBaseFormat
) {
177 state
->SourceRGB
[0] = GL_PREVIOUS
;
180 case GL_LUMINANCE_ALPHA
:
190 state
->SourceA
[0] = GL_PREVIOUS
;
195 "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
200 if (mode
== GL_REPLACE_EXT
)
206 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: mode
;
211 mode_rgb
= GL_INTERPOLATE
;
214 state
->SourceA
[0] = GL_PREVIOUS
;
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".
220 switch (texBaseFormat
) {
223 case GL_LUMINANCE_ALPHA
:
225 state
->SourceRGB
[0] = GL_PREVIOUS
;
231 mode_rgb
= GL_REPLACE
;
234 state
->SourceRGB
[2] = GL_TEXTURE
;
240 mode_rgb
= GL_INTERPOLATE
;
241 mode_a
= GL_MODULATE
;
243 switch (texBaseFormat
) {
245 mode_rgb
= GL_REPLACE
;
248 mode_a
= GL_INTERPOLATE
;
249 state
->SourceA
[0] = GL_CONSTANT
;
250 state
->OperandA
[2] = GL_SRC_ALPHA
;
256 case GL_LUMINANCE_ALPHA
:
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
;
268 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: GL_ADD
;
269 mode_a
= (texBaseFormat
== GL_INTENSITY
) ? GL_ADD
: GL_MODULATE
;
274 "Invalid texture env mode 0x%x in calculate_derived_texenv",
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
;
286 /* GL_ARB_multitexture */
287 static ALWAYS_INLINE
void
288 active_texture(GLenum texture
, bool no_error
)
290 const GLuint texUnit
= texture
- GL_TEXTURE0
;
292 GET_CURRENT_CONTEXT(ctx
);
294 if (MESA_VERBOSE
& (VERBOSE_API
|VERBOSE_TEXTURE
))
295 _mesa_debug(ctx
, "glActiveTexture %s\n",
296 _mesa_enum_to_string(texture
));
298 if (ctx
->Texture
.CurrentUnit
== texUnit
)
302 GLuint k
= _mesa_max_tex_unit(ctx
);
304 assert(k
<= ARRAY_SIZE(ctx
->Texture
.Unit
));
307 _mesa_error(ctx
, GL_INVALID_ENUM
, "glActiveTexture(texture=%s)",
308 _mesa_enum_to_string(texture
));
314 /* The below flush call seems useless because
315 * gl_context::Texture::CurrentUnit is not used by
316 * _mesa_update_texture_state() and friends.
318 * However removing the flush
319 * introduced some blinking textures in UT2004. More investigation is
320 * needed to find the root cause.
322 * https://bugs.freedesktop.org/show_bug.cgi?id=105436
324 FLUSH_VERTICES(ctx
, _NEW_TEXTURE_STATE
);
326 ctx
->Texture
.CurrentUnit
= texUnit
;
327 if (ctx
->Transform
.MatrixMode
== GL_TEXTURE
) {
328 /* update current stack pointer */
329 ctx
->CurrentStack
= &ctx
->TextureMatrixStack
[texUnit
];
335 _mesa_ActiveTexture_no_error(GLenum texture
)
337 active_texture(texture
, true);
342 _mesa_ActiveTexture(GLenum texture
)
344 active_texture(texture
, false);
348 /* GL_ARB_multitexture */
350 _mesa_ClientActiveTexture(GLenum texture
)
352 GET_CURRENT_CONTEXT(ctx
);
353 GLuint texUnit
= texture
- GL_TEXTURE0
;
355 if (MESA_VERBOSE
& (VERBOSE_API
| VERBOSE_TEXTURE
))
356 _mesa_debug(ctx
, "glClientActiveTexture %s\n",
357 _mesa_enum_to_string(texture
));
359 if (ctx
->Array
.ActiveTexture
== texUnit
)
362 if (texUnit
>= ctx
->Const
.MaxTextureCoordUnits
) {
363 _mesa_error(ctx
, GL_INVALID_ENUM
, "glClientActiveTexture(texture=%s)",
364 _mesa_enum_to_string(texture
));
368 /* Don't flush vertices. This is a "latched" state. */
369 ctx
->Array
.ActiveTexture
= texUnit
;
374 /**********************************************************************/
375 /***** State management *****/
376 /**********************************************************************/
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.
385 * \param ctx GL context.
388 _mesa_update_texture_matrices(struct gl_context
*ctx
)
392 ctx
->Texture
._TexMatEnabled
= 0x0;
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
);
399 if (ctx
->Texture
.Unit
[u
]._Current
&&
400 ctx
->TextureMatrixStack
[u
].Top
->type
!= MATRIX_IDENTITY
)
401 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(u
);
408 * Translate GL combiner state into a MODE_x value
411 tex_combine_translate_mode(GLenum envMode
, GLenum mode
)
414 case GL_REPLACE
: return TEXENV_MODE_REPLACE
;
415 case GL_MODULATE
: return TEXENV_MODE_MODULATE
;
417 if (envMode
== GL_COMBINE4_NV
)
418 return TEXENV_MODE_ADD_PRODUCTS_NV
;
420 return TEXENV_MODE_ADD
;
422 if (envMode
== GL_COMBINE4_NV
)
423 return TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV
;
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
;
436 unreachable("Invalid TexEnv Combine mode");
442 tex_combine_translate_source(GLenum src
)
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
;
460 unreachable("Invalid TexEnv Combine argument source");
466 tex_combine_translate_operand(GLenum 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
;
474 unreachable("Invalid TexEnv Combine argument source");
480 pack_tex_combine(struct gl_fixedfunc_texture_unit
*texUnit
)
482 struct gl_tex_env_combine_state
*state
= texUnit
->_CurrentCombine
;
483 struct gl_tex_env_combine_packed
*packed
= &texUnit
->_CurrentCombinePacked
;
485 memset(packed
, 0, sizeof *packed
);
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
;
494 for (int i
= 0; i
< state
->_NumArgsRGB
; ++i
)
496 packed
->ArgsRGB
[i
].Source
= tex_combine_translate_source(state
->SourceRGB
[i
]);
497 packed
->ArgsRGB
[i
].Operand
= tex_combine_translate_operand(state
->OperandRGB
[i
]);
500 for (int i
= 0; i
< state
->_NumArgsA
; ++i
)
502 packed
->ArgsA
[i
].Source
= tex_combine_translate_source(state
->SourceA
[i
]);
503 packed
->ArgsA
[i
].Operand
= tex_combine_translate_operand(state
->OperandA
[i
]);
509 * Examine texture unit's combine/env state to update derived state.
512 update_tex_combine(struct gl_context
*ctx
,
513 struct gl_texture_unit
*texUnit
,
514 struct gl_fixedfunc_texture_unit
*fftexUnit
)
516 struct gl_tex_env_combine_state
*combine
;
518 /* No combiners will apply to this. */
519 if (texUnit
->_Current
->Target
== GL_TEXTURE_BUFFER
)
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
526 if (fftexUnit
->EnvMode
== GL_COMBINE
||
527 fftexUnit
->EnvMode
== GL_COMBINE4_NV
) {
528 fftexUnit
->_CurrentCombine
= & fftexUnit
->Combine
;
531 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
532 GLenum format
= texObj
->Image
[0][texObj
->BaseLevel
]->_BaseFormat
;
534 if (format
== GL_DEPTH_COMPONENT
|| format
== GL_DEPTH_STENCIL_EXT
) {
535 format
= texObj
->DepthMode
;
537 calculate_derived_texenv(&fftexUnit
->_EnvMode
, fftexUnit
->EnvMode
, format
);
538 fftexUnit
->_CurrentCombine
= & fftexUnit
->_EnvMode
;
541 combine
= fftexUnit
->_CurrentCombine
;
543 /* Determine number of source RGB terms in the combiner function */
544 switch (combine
->ModeRGB
) {
546 combine
->_NumArgsRGB
= 1;
550 if (fftexUnit
->EnvMode
== GL_COMBINE4_NV
)
551 combine
->_NumArgsRGB
= 4;
553 combine
->_NumArgsRGB
= 2;
559 case GL_DOT3_RGB_EXT
:
560 case GL_DOT3_RGBA_EXT
:
561 combine
->_NumArgsRGB
= 2;
564 case GL_MODULATE_ADD_ATI
:
565 case GL_MODULATE_SIGNED_ADD_ATI
:
566 case GL_MODULATE_SUBTRACT_ATI
:
567 combine
->_NumArgsRGB
= 3;
570 combine
->_NumArgsRGB
= 0;
571 _mesa_problem(ctx
, "invalid RGB combine mode in update_texture_state");
575 /* Determine number of source Alpha terms in the combiner function */
576 switch (combine
->ModeA
) {
578 combine
->_NumArgsA
= 1;
582 if (fftexUnit
->EnvMode
== GL_COMBINE4_NV
)
583 combine
->_NumArgsA
= 4;
585 combine
->_NumArgsA
= 2;
589 combine
->_NumArgsA
= 2;
592 case GL_MODULATE_ADD_ATI
:
593 case GL_MODULATE_SIGNED_ADD_ATI
:
594 case GL_MODULATE_SUBTRACT_ATI
:
595 combine
->_NumArgsA
= 3;
598 combine
->_NumArgsA
= 0;
599 _mesa_problem(ctx
, "invalid Alpha combine mode in update_texture_state");
603 pack_tex_combine(fftexUnit
);
607 update_texgen(struct gl_context
*ctx
)
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
];
616 texUnit
->_GenFlags
= 0x0;
618 if (!(ctx
->Texture
._EnabledCoordUnits
& (1 << unit
)))
621 if (texUnit
->TexGenEnabled
) {
622 if (texUnit
->TexGenEnabled
& S_BIT
) {
623 texUnit
->_GenFlags
|= texUnit
->GenS
._ModeBit
;
625 if (texUnit
->TexGenEnabled
& T_BIT
) {
626 texUnit
->_GenFlags
|= texUnit
->GenT
._ModeBit
;
628 if (texUnit
->TexGenEnabled
& R_BIT
) {
629 texUnit
->_GenFlags
|= texUnit
->GenR
._ModeBit
;
631 if (texUnit
->TexGenEnabled
& Q_BIT
) {
632 texUnit
->_GenFlags
|= texUnit
->GenQ
._ModeBit
;
635 ctx
->Texture
._TexGenEnabled
|= ENABLE_TEXGEN(unit
);
636 ctx
->Texture
._GenFlags
|= texUnit
->_GenFlags
;
639 assert(unit
< ARRAY_SIZE(ctx
->TextureMatrixStack
));
640 if (ctx
->TextureMatrixStack
[unit
].Top
->type
!= MATRIX_IDENTITY
)
641 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(unit
);
645 static struct gl_texture_object
*
646 update_single_program_texture(struct gl_context
*ctx
, struct gl_program
*prog
,
649 gl_texture_index target_index
;
650 struct gl_texture_unit
*texUnit
;
651 struct gl_texture_object
*texObj
;
652 struct gl_sampler_object
*sampler
;
654 texUnit
= &ctx
->Texture
.Unit
[unit
];
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"):
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."
666 target_index
= ffs(prog
->TexturesUsed
[unit
]) - 1;
667 texObj
= texUnit
->CurrentTex
[target_index
];
669 sampler
= texUnit
->Sampler
?
670 texUnit
->Sampler
: &texObj
->Sampler
;
672 if (likely(texObj
)) {
673 if (_mesa_is_texture_complete(texObj
, sampler
,
674 ctx
->Const
.ForceIntegerTexNearest
))
677 _mesa_test_texobj_completeness(ctx
, texObj
);
678 if (_mesa_is_texture_complete(texObj
, sampler
,
679 ctx
->Const
.ForceIntegerTexNearest
))
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"):
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
692 * Mesa implements this by creating a hidden texture object with a pixel of
695 texObj
= _mesa_get_fallback_texture(ctx
, target_index
);
702 update_single_program_texture_state(struct gl_context
*ctx
,
703 struct gl_program
*prog
,
705 BITSET_WORD
*enabled_texture_units
)
707 struct gl_texture_object
*texObj
;
709 texObj
= update_single_program_texture(ctx
, prog
, unit
);
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
);
718 update_program_texture_state(struct gl_context
*ctx
, struct gl_program
**prog
,
719 BITSET_WORD
*enabled_texture_units
)
723 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
730 mask
= prog
[i
]->SamplersUsed
;
733 s
= u_bit_scan(&mask
);
735 update_single_program_texture_state(ctx
, prog
[i
],
736 prog
[i
]->SamplerUnits
[s
],
737 enabled_texture_units
);
740 if (unlikely(prog
[i
]->sh
.HasBoundBindlessSampler
)) {
741 /* Loop over bindless samplers bound to texture units.
743 for (s
= 0; s
< prog
[i
]->sh
.NumBindlessSamplers
; s
++) {
744 struct gl_bindless_sampler
*sampler
=
745 &prog
[i
]->sh
.BindlessSamplers
[s
];
750 update_single_program_texture_state(ctx
, prog
[i
], sampler
->unit
,
751 enabled_texture_units
);
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
) &
765 update_ff_texture_state(struct gl_context
*ctx
,
766 BITSET_WORD
*enabled_texture_units
)
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
];
777 if (fftexUnit
->Enabled
== 0x0)
780 /* If a shader already dictated what texture target was used for this
781 * unit, just go along with it.
783 if (BITSET_TEST(enabled_texture_units
, unit
))
786 /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"):
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:
796 * • cube map texture
797 * • three-dimensional texture
798 * • rectangular texture
799 * • two-dimensional texture
800 * • one-dimensional texture"
802 * Note that the TEXTURE_x_INDEX values are in high to low priority.
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
814 mask
= fftexUnit
->Enabled
;
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
;
821 if (!_mesa_is_texture_complete(texObj
, sampler
,
822 ctx
->Const
.ForceIntegerTexNearest
)) {
823 _mesa_test_texobj_completeness(ctx
, texObj
);
825 if (_mesa_is_texture_complete(texObj
, sampler
,
826 ctx
->Const
.ForceIntegerTexNearest
)) {
827 _mesa_reference_texobj(&texUnit
->_Current
, texObj
);
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
);
841 ctx
->Texture
._EnabledCoordUnits
|= 1 << unit
;
843 update_tex_combine(ctx
, texUnit
, fftexUnit
);
848 fix_missing_textures_for_atifs(struct gl_context
*ctx
,
849 struct gl_program
*prog
,
850 BITSET_WORD
*enabled_texture_units
)
852 GLbitfield mask
= prog
->SamplersUsed
;
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;
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
);
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,
877 * \param ctx GL context.
880 _mesa_update_texture_state(struct gl_context
*ctx
)
882 struct gl_program
*prog
[MESA_SHADER_STAGES
];
884 int old_max_unit
= ctx
->Texture
._MaxEnabledTexImageUnit
;
885 BITSET_DECLARE(enabled_texture_units
, MAX_COMBINED_TEXTURE_IMAGE_UNITS
);
887 memcpy(prog
, ctx
->_Shader
->CurrentProgram
, sizeof(prog
));
889 if (prog
[MESA_SHADER_FRAGMENT
] == NULL
&&
890 _mesa_arb_fragment_program_enabled(ctx
)) {
891 prog
[MESA_SHADER_FRAGMENT
] = ctx
->FragmentProgram
.Current
;
894 /* TODO: only set this if there are actual changes */
895 ctx
->NewState
|= _NEW_TEXTURE_OBJECT
| _NEW_TEXTURE_STATE
;
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;
903 memset(&enabled_texture_units
, 0, sizeof(enabled_texture_units
));
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
910 update_program_texture_state(ctx
, prog
, enabled_texture_units
);
912 /* Also pull in any textures necessary for fixed function fragment shading.
914 if (!prog
[MESA_SHADER_FRAGMENT
])
915 update_ff_texture_state(ctx
, enabled_texture_units
);
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
);
922 for (i
= ctx
->Texture
._MaxEnabledTexImageUnit
+ 1; i
<= old_max_unit
; i
++) {
923 _mesa_reference_texobj(&ctx
->Texture
.Unit
[i
]._Current
, NULL
);
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
);
933 if (!prog
[MESA_SHADER_FRAGMENT
] || !prog
[MESA_SHADER_VERTEX
])
938 /**********************************************************************/
939 /***** Initialization *****/
940 /**********************************************************************/
943 * Allocate the proxy textures for the given context.
945 * \param ctx the context to allocate proxies for.
947 * \return GL_TRUE on success, or GL_FALSE on failure
949 * If run out of memory part way through the allocations, clean up and return
953 alloc_proxy_textures( struct gl_context
*ctx
)
955 /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
958 static const GLenum targets
[] = {
959 GL_TEXTURE_2D_MULTISAMPLE
,
960 GL_TEXTURE_2D_MULTISAMPLE_ARRAY
,
961 GL_TEXTURE_CUBE_MAP_ARRAY
,
963 GL_TEXTURE_2D_ARRAY_EXT
,
964 GL_TEXTURE_1D_ARRAY_EXT
,
965 GL_TEXTURE_EXTERNAL_OES
,
968 GL_TEXTURE_RECTANGLE_NV
,
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
);
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 */
983 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
989 assert(ctx
->Texture
.ProxyTex
[0]->RefCount
== 1); /* sanity check */
995 * Initialize texture state for the given context.
998 _mesa_init_texture(struct gl_context
*ctx
)
1003 ctx
->Texture
.CurrentUnit
= 0; /* multitexture */
1005 /* Appendix F.2 of the OpenGL ES 3.0 spec says:
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."
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.
1020 ctx
->Texture
.CubeMapSeamless
= ctx
->API
== API_OPENGLES2
;
1022 for (u
= 0; u
< ARRAY_SIZE(ctx
->Texture
.Unit
); u
++) {
1023 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[u
];
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
]);
1032 texUnit
->_BoundTextures
= 0;
1035 for (u
= 0; u
< ARRAY_SIZE(ctx
->Texture
.FixedFuncUnit
); u
++) {
1036 struct gl_fixedfunc_texture_unit
*texUnit
=
1037 &ctx
->Texture
.FixedFuncUnit
[u
];
1039 texUnit
->EnvMode
= GL_MODULATE
;
1040 ASSIGN_4V( texUnit
->EnvColor
, 0.0, 0.0, 0.0, 0.0 );
1042 texUnit
->Combine
= default_combine_state
;
1043 texUnit
->_EnvMode
= default_combine_state
;
1044 texUnit
->_CurrentCombine
= & texUnit
->_EnvMode
;
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
;
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 );
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.
1071 assert(ctx
->Shared
->DefaultTex
[TEXTURE_1D_INDEX
]->RefCount
1072 >= MAX_COMBINED_TEXTURE_IMAGE_UNITS
+ 1);
1074 /* Allocate proxy textures */
1075 if (!alloc_proxy_textures( ctx
))
1078 /* GL_ARB_texture_buffer_object */
1079 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
, NULL
);
1081 ctx
->Texture
.NumCurrentTexUsed
= 0;
1088 * Free dynamically-allocted texture data attached to the given context.
1091 _mesa_free_texture_data(struct gl_context
*ctx
)
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
);
1100 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++) {
1101 _mesa_reference_texobj(&ctx
->Texture
.Unit
[u
].CurrentTex
[tgt
], NULL
);
1105 /* Free proxy texture objects */
1106 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++)
1107 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
1109 /* GL_ARB_texture_buffer_object */
1110 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
, NULL
);
1112 for (u
= 0; u
< ARRAY_SIZE(ctx
->Texture
.Unit
); u
++) {
1113 _mesa_reference_sampler_object(ctx
, &ctx
->Texture
.Unit
[u
].Sampler
, NULL
);
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
1124 _mesa_update_default_objects_texture(struct gl_context
*ctx
)
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
]);