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.
32 #include "bufferobj.h"
38 #include "shaderimage.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
].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
;
91 /* GL_EXT_texture_env_combine */
92 dst
->Texture
.Unit
[u
].Combine
= src
->Texture
.Unit
[u
].Combine
;
94 /* GL_ATI_envmap_bumpmap - need this? */
95 dst
->Texture
.Unit
[u
].BumpTarget
= src
->Texture
.Unit
[u
].BumpTarget
;
96 COPY_4V(dst
->Texture
.Unit
[u
].RotMatrix
, src
->Texture
.Unit
[u
].RotMatrix
);
99 * XXX strictly speaking, we should compare texture names/ids and
100 * bind textures in the dest context according to id. For now, only
101 * copy bindings if the contexts share the same pool of textures to
102 * avoid refcounting bugs.
104 if (dst
->Shared
== src
->Shared
) {
105 /* copy texture object bindings, not contents of texture objects */
106 _mesa_lock_context_textures(dst
);
108 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
109 _mesa_reference_texobj(&dst
->Texture
.Unit
[u
].CurrentTex
[tex
],
110 src
->Texture
.Unit
[u
].CurrentTex
[tex
]);
111 if (src
->Texture
.Unit
[u
].CurrentTex
[tex
]) {
112 dst
->Texture
.NumCurrentTexUsed
=
113 MAX2(dst
->Texture
.NumCurrentTexUsed
, u
+ 1);
116 dst
->Texture
.Unit
[u
]._BoundTextures
= src
->Texture
.Unit
[u
]._BoundTextures
;
117 _mesa_unlock_context_textures(dst
);
127 _mesa_print_texunit_state( struct gl_context
*ctx
, GLuint unit
)
129 const struct gl_texture_unit
*texUnit
= ctx
->Texture
.Unit
+ unit
;
130 printf("Texture Unit %d\n", unit
);
131 printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit
->EnvMode
));
132 printf(" GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.ModeRGB
));
133 printf(" GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.ModeA
));
134 printf(" GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[0]));
135 printf(" GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[1]));
136 printf(" GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[2]));
137 printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[0]));
138 printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[1]));
139 printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[2]));
140 printf(" GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[0]));
141 printf(" GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[1]));
142 printf(" GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[2]));
143 printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[0]));
144 printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[1]));
145 printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[2]));
146 printf(" GL_RGB_SCALE = %d\n", 1 << texUnit
->Combine
.ScaleShiftRGB
);
147 printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit
->Combine
.ScaleShiftA
);
148 printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit
->EnvColor
[0], texUnit
->EnvColor
[1], texUnit
->EnvColor
[2], texUnit
->EnvColor
[3]);
153 /**********************************************************************/
154 /* Texture Environment */
155 /**********************************************************************/
158 * Convert "classic" texture environment to ARB_texture_env_combine style
161 * \param state texture_env_combine state vector to be filled-in.
162 * \param mode Classic texture environment mode (i.e., \c GL_REPLACE,
163 * \c GL_BLEND, \c GL_DECAL, etc.).
164 * \param texBaseFormat Base format of the texture associated with the
168 calculate_derived_texenv( struct gl_tex_env_combine_state
*state
,
169 GLenum mode
, GLenum texBaseFormat
)
174 *state
= default_combine_state
;
176 switch (texBaseFormat
) {
178 state
->SourceRGB
[0] = GL_PREVIOUS
;
181 case GL_LUMINANCE_ALPHA
:
192 state
->SourceA
[0] = GL_PREVIOUS
;
197 "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
202 if (mode
== GL_REPLACE_EXT
)
208 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: mode
;
213 mode_rgb
= GL_INTERPOLATE
;
216 state
->SourceA
[0] = GL_PREVIOUS
;
218 /* Having alpha / luminance / intensity textures replace using the
219 * incoming fragment color matches the definition in NV_texture_shader.
220 * The 1.5 spec simply marks these as "undefined".
222 switch (texBaseFormat
) {
225 case GL_LUMINANCE_ALPHA
:
227 state
->SourceRGB
[0] = GL_PREVIOUS
;
234 mode_rgb
= GL_REPLACE
;
237 state
->SourceRGB
[2] = GL_TEXTURE
;
243 mode_rgb
= GL_INTERPOLATE
;
244 mode_a
= GL_MODULATE
;
246 switch (texBaseFormat
) {
248 mode_rgb
= GL_REPLACE
;
251 mode_a
= GL_INTERPOLATE
;
252 state
->SourceA
[0] = GL_CONSTANT
;
253 state
->OperandA
[2] = GL_SRC_ALPHA
;
259 case GL_LUMINANCE_ALPHA
:
263 state
->SourceRGB
[2] = GL_TEXTURE
;
264 state
->SourceA
[2] = GL_TEXTURE
;
265 state
->SourceRGB
[0] = GL_CONSTANT
;
266 state
->OperandRGB
[2] = GL_SRC_COLOR
;
272 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: GL_ADD
;
273 mode_a
= (texBaseFormat
== GL_INTENSITY
) ? GL_ADD
: GL_MODULATE
;
278 "Invalid texture env mode 0x%x in calculate_derived_texenv",
283 state
->ModeRGB
= (state
->SourceRGB
[0] != GL_PREVIOUS
)
284 ? mode_rgb
: GL_REPLACE
;
285 state
->ModeA
= (state
->SourceA
[0] != GL_PREVIOUS
)
286 ? mode_a
: GL_REPLACE
;
292 /* GL_ARB_multitexture */
294 _mesa_ActiveTexture(GLenum texture
)
296 const GLuint texUnit
= texture
- GL_TEXTURE0
;
298 GET_CURRENT_CONTEXT(ctx
);
300 /* See OpenGL spec for glActiveTexture: */
301 k
= MAX2(ctx
->Const
.MaxCombinedTextureImageUnits
,
302 ctx
->Const
.MaxTextureCoordUnits
);
304 ASSERT(k
<= Elements(ctx
->Texture
.Unit
));
306 if (MESA_VERBOSE
& (VERBOSE_API
|VERBOSE_TEXTURE
))
307 _mesa_debug(ctx
, "glActiveTexture %s\n",
308 _mesa_lookup_enum_by_nr(texture
));
311 _mesa_error(ctx
, GL_INVALID_ENUM
, "glActiveTexture(texture=%s)",
312 _mesa_lookup_enum_by_nr(texture
));
316 if (ctx
->Texture
.CurrentUnit
== texUnit
)
319 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
);
321 ctx
->Texture
.CurrentUnit
= texUnit
;
322 if (ctx
->Transform
.MatrixMode
== GL_TEXTURE
) {
323 /* update current stack pointer */
324 ctx
->CurrentStack
= &ctx
->TextureMatrixStack
[texUnit
];
329 /* GL_ARB_multitexture */
331 _mesa_ClientActiveTexture(GLenum texture
)
333 GET_CURRENT_CONTEXT(ctx
);
334 GLuint texUnit
= texture
- GL_TEXTURE0
;
336 if (MESA_VERBOSE
& (VERBOSE_API
| VERBOSE_TEXTURE
))
337 _mesa_debug(ctx
, "glClientActiveTexture %s\n",
338 _mesa_lookup_enum_by_nr(texture
));
340 if (texUnit
>= ctx
->Const
.MaxTextureCoordUnits
) {
341 _mesa_error(ctx
, GL_INVALID_ENUM
, "glClientActiveTexture(texture)");
345 if (ctx
->Array
.ActiveTexture
== texUnit
)
348 FLUSH_VERTICES(ctx
, _NEW_ARRAY
);
349 ctx
->Array
.ActiveTexture
= texUnit
;
354 /**********************************************************************/
355 /***** State management *****/
356 /**********************************************************************/
360 * \note This routine refers to derived texture attribute values to
361 * compute the ENABLE_TEXMAT flags, but is only called on
362 * _NEW_TEXTURE_MATRIX. On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
363 * flags are updated by _mesa_update_textures(), below.
365 * \param ctx GL context.
368 update_texture_matrices( struct gl_context
*ctx
)
372 ctx
->Texture
._TexMatEnabled
= 0x0;
374 for (u
= 0; u
< ctx
->Const
.MaxTextureCoordUnits
; u
++) {
375 ASSERT(u
< Elements(ctx
->TextureMatrixStack
));
376 if (_math_matrix_is_dirty(ctx
->TextureMatrixStack
[u
].Top
)) {
377 _math_matrix_analyse( ctx
->TextureMatrixStack
[u
].Top
);
379 if (ctx
->Texture
.Unit
[u
]._Current
&&
380 ctx
->TextureMatrixStack
[u
].Top
->type
!= MATRIX_IDENTITY
)
381 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(u
);
388 * Examine texture unit's combine/env state to update derived state.
391 update_tex_combine(struct gl_context
*ctx
, struct gl_texture_unit
*texUnit
)
393 struct gl_tex_env_combine_state
*combine
;
395 /* No combiners will apply to this. */
396 if (texUnit
->_Current
->Target
== GL_TEXTURE_BUFFER
)
399 /* Set the texUnit->_CurrentCombine field to point to the user's combiner
400 * state, or the combiner state which is derived from traditional texenv
403 if (texUnit
->EnvMode
== GL_COMBINE
||
404 texUnit
->EnvMode
== GL_COMBINE4_NV
) {
405 texUnit
->_CurrentCombine
= & texUnit
->Combine
;
408 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
409 GLenum format
= texObj
->Image
[0][texObj
->BaseLevel
]->_BaseFormat
;
411 if (format
== GL_DEPTH_COMPONENT
|| format
== GL_DEPTH_STENCIL_EXT
) {
412 format
= texObj
->DepthMode
;
414 calculate_derived_texenv(&texUnit
->_EnvMode
, texUnit
->EnvMode
, format
);
415 texUnit
->_CurrentCombine
= & texUnit
->_EnvMode
;
418 combine
= texUnit
->_CurrentCombine
;
420 /* Determine number of source RGB terms in the combiner function */
421 switch (combine
->ModeRGB
) {
423 combine
->_NumArgsRGB
= 1;
427 if (texUnit
->EnvMode
== GL_COMBINE4_NV
)
428 combine
->_NumArgsRGB
= 4;
430 combine
->_NumArgsRGB
= 2;
436 case GL_DOT3_RGB_EXT
:
437 case GL_DOT3_RGBA_EXT
:
438 combine
->_NumArgsRGB
= 2;
441 case GL_MODULATE_ADD_ATI
:
442 case GL_MODULATE_SIGNED_ADD_ATI
:
443 case GL_MODULATE_SUBTRACT_ATI
:
444 combine
->_NumArgsRGB
= 3;
446 case GL_BUMP_ENVMAP_ATI
:
447 /* no real arguments for this case */
448 combine
->_NumArgsRGB
= 0;
451 combine
->_NumArgsRGB
= 0;
452 _mesa_problem(ctx
, "invalid RGB combine mode in update_texture_state");
456 /* Determine number of source Alpha terms in the combiner function */
457 switch (combine
->ModeA
) {
459 combine
->_NumArgsA
= 1;
463 if (texUnit
->EnvMode
== GL_COMBINE4_NV
)
464 combine
->_NumArgsA
= 4;
466 combine
->_NumArgsA
= 2;
470 combine
->_NumArgsA
= 2;
473 case GL_MODULATE_ADD_ATI
:
474 case GL_MODULATE_SIGNED_ADD_ATI
:
475 case GL_MODULATE_SUBTRACT_ATI
:
476 combine
->_NumArgsA
= 3;
479 combine
->_NumArgsA
= 0;
480 _mesa_problem(ctx
, "invalid Alpha combine mode in update_texture_state");
486 update_texgen(struct gl_context
*ctx
)
490 /* Setup texgen for those texture coordinate sets that are in use */
491 for (unit
= 0; unit
< ctx
->Const
.MaxTextureCoordUnits
; unit
++) {
492 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
494 texUnit
->_GenFlags
= 0x0;
496 if (!(ctx
->Texture
._EnabledCoordUnits
& (1 << unit
)))
499 if (texUnit
->TexGenEnabled
) {
500 if (texUnit
->TexGenEnabled
& S_BIT
) {
501 texUnit
->_GenFlags
|= texUnit
->GenS
._ModeBit
;
503 if (texUnit
->TexGenEnabled
& T_BIT
) {
504 texUnit
->_GenFlags
|= texUnit
->GenT
._ModeBit
;
506 if (texUnit
->TexGenEnabled
& R_BIT
) {
507 texUnit
->_GenFlags
|= texUnit
->GenR
._ModeBit
;
509 if (texUnit
->TexGenEnabled
& Q_BIT
) {
510 texUnit
->_GenFlags
|= texUnit
->GenQ
._ModeBit
;
513 ctx
->Texture
._TexGenEnabled
|= ENABLE_TEXGEN(unit
);
514 ctx
->Texture
._GenFlags
|= texUnit
->_GenFlags
;
517 ASSERT(unit
< Elements(ctx
->TextureMatrixStack
));
518 if (ctx
->TextureMatrixStack
[unit
].Top
->type
!= MATRIX_IDENTITY
)
519 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(unit
);
523 static struct gl_texture_object
*
524 update_single_program_texture(struct gl_context
*ctx
, struct gl_program
*prog
,
527 gl_texture_index target_index
;
528 struct gl_texture_unit
*texUnit
;
529 struct gl_texture_object
*texObj
;
530 struct gl_sampler_object
*sampler
;
533 if (!(prog
->SamplersUsed
& (1 << s
)))
536 unit
= prog
->SamplerUnits
[s
];
537 texUnit
= &ctx
->Texture
.Unit
[unit
];
539 /* Note: If more than one bit was set in TexturesUsed[unit], then we should
540 * have had the draw call rejected already. From the GL 4.4 specification,
541 * section 7.10 ("Samplers"):
543 * "It is not allowed to have variables of different sampler types
544 * pointing to the same texture image unit within a program
545 * object. This situation can only be detected at the next rendering
546 * command issued which triggers shader invocations, and an
547 * INVALID_OPERATION error will then be generated."
549 target_index
= ffs(prog
->TexturesUsed
[unit
]) - 1;
550 texObj
= texUnit
->CurrentTex
[target_index
];
552 sampler
= texUnit
->Sampler
?
553 texUnit
->Sampler
: &texObj
->Sampler
;
555 if (likely(texObj
)) {
556 if (_mesa_is_texture_complete(texObj
, sampler
))
559 _mesa_test_texobj_completeness(ctx
, texObj
);
560 if (_mesa_is_texture_complete(texObj
, sampler
))
564 /* If we've reached this point, we didn't find a complete texture of the
565 * shader's target. From the GL 4.4 core specification, section 11.1.3.5
566 * ("Texture Access"):
568 * "If a sampler is used in a shader and the sampler’s associated
569 * texture is not complete, as defined in section 8.17, (0, 0, 0, 1)
570 * will be returned for a non-shadow sampler and 0 for a shadow
573 * Mesa implements this by creating a hidden texture object with a pixel of
576 texObj
= _mesa_get_fallback_texture(ctx
, target_index
);
583 update_program_texture_state(struct gl_context
*ctx
, struct gl_program
**prog
,
584 BITSET_WORD
*enabled_texture_units
)
588 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
594 /* We can't only do the shifting trick as the loop condition because if
595 * sampler 31 is active, the next iteration tries to shift by 32, which is
598 for (s
= 0; s
< MAX_SAMPLERS
&& (1 << s
) <= prog
[i
]->SamplersUsed
; s
++) {
599 struct gl_texture_object
*texObj
;
601 texObj
= update_single_program_texture(ctx
, prog
[i
], s
);
603 int unit
= prog
[i
]->SamplerUnits
[s
];
604 _mesa_reference_texobj(&ctx
->Texture
.Unit
[unit
]._Current
, texObj
);
605 BITSET_SET(enabled_texture_units
, unit
);
606 ctx
->Texture
._MaxEnabledTexImageUnit
=
607 MAX2(ctx
->Texture
._MaxEnabledTexImageUnit
, (int)unit
);
612 if (prog
[MESA_SHADER_FRAGMENT
]) {
613 const GLuint coordMask
= (1 << MAX_TEXTURE_COORD_UNITS
) - 1;
614 ctx
->Texture
._EnabledCoordUnits
|=
615 (prog
[MESA_SHADER_FRAGMENT
]->InputsRead
>> VARYING_SLOT_TEX0
) &
621 update_ff_texture_state(struct gl_context
*ctx
,
622 BITSET_WORD
*enabled_texture_units
)
626 for (unit
= 0; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
627 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
630 if (texUnit
->Enabled
== 0x0)
633 /* If a shader already dictated what texture target was used for this
634 * unit, just go along with it.
636 if (BITSET_TEST(enabled_texture_units
, unit
))
639 /* From the GL 4.4 compat specification, section 16.2 ("Texture Application"):
641 * "Texturing is enabled or disabled using the generic Enable and
642 * Disable commands, respectively, with the symbolic constants
643 * TEXTURE_1D, TEXTURE_2D, TEXTURE_RECTANGLE, TEXTURE_3D, or
644 * TEXTURE_CUBE_MAP to enable the one-, two-, rectangular,
645 * three-dimensional, or cube map texture, respectively. If more
646 * than one of these textures is enabled, the first one enabled
647 * from the following list is used:
649 * • cube map texture
650 * • three-dimensional texture
651 * • rectangular texture
652 * • two-dimensional texture
653 * • one-dimensional texture"
655 * Note that the TEXTURE_x_INDEX values are in high to low priority.
658 * "If a texture unit is disabled or has an invalid or incomplete
659 * texture (as defined in section 8.17) bound to it, then blending
660 * is disabled for that texture unit. If the texture environment
661 * for a given enabled texture unit references a disabled texture
662 * unit, or an invalid or incomplete texture that is bound to
663 * another unit, then the results of texture blending are
666 for (texIndex
= 0; texIndex
< NUM_TEXTURE_TARGETS
; texIndex
++) {
667 if (texUnit
->Enabled
& (1 << texIndex
)) {
668 struct gl_texture_object
*texObj
= texUnit
->CurrentTex
[texIndex
];
669 struct gl_sampler_object
*sampler
= texUnit
->Sampler
?
670 texUnit
->Sampler
: &texObj
->Sampler
;
672 if (!_mesa_is_texture_complete(texObj
, sampler
)) {
673 _mesa_test_texobj_completeness(ctx
, texObj
);
675 if (_mesa_is_texture_complete(texObj
, sampler
)) {
676 _mesa_reference_texobj(&texUnit
->_Current
, texObj
);
682 if (texIndex
== NUM_TEXTURE_TARGETS
)
685 /* if we get here, we know this texture unit is enabled */
686 BITSET_SET(enabled_texture_units
, unit
);
687 ctx
->Texture
._MaxEnabledTexImageUnit
=
688 MAX2(ctx
->Texture
._MaxEnabledTexImageUnit
, (int)unit
);
690 ctx
->Texture
._EnabledCoordUnits
|= 1 << unit
;
692 update_tex_combine(ctx
, texUnit
);
697 * \note This routine refers to derived texture matrix values to
698 * compute the ENABLE_TEXMAT flags, but is only called on
699 * _NEW_TEXTURE. On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
700 * flags are updated by _mesa_update_texture_matrices, above.
702 * \param ctx GL context.
705 update_texture_state( struct gl_context
*ctx
)
707 struct gl_program
*prog
[MESA_SHADER_STAGES
];
709 int old_max_unit
= ctx
->Texture
._MaxEnabledTexImageUnit
;
710 BITSET_DECLARE(enabled_texture_units
, MAX_COMBINED_TEXTURE_IMAGE_UNITS
);
712 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
713 if (ctx
->_Shader
->CurrentProgram
[i
] &&
714 ctx
->_Shader
->CurrentProgram
[i
]->LinkStatus
) {
715 prog
[i
] = ctx
->_Shader
->CurrentProgram
[i
]->_LinkedShaders
[i
]->Program
;
717 if (i
== MESA_SHADER_FRAGMENT
&& ctx
->FragmentProgram
._Enabled
)
718 prog
[i
] = &ctx
->FragmentProgram
.Current
->Base
;
724 /* TODO: only set this if there are actual changes */
725 ctx
->NewState
|= _NEW_TEXTURE
;
727 ctx
->Texture
._GenFlags
= 0x0;
728 ctx
->Texture
._TexMatEnabled
= 0x0;
729 ctx
->Texture
._TexGenEnabled
= 0x0;
730 ctx
->Texture
._MaxEnabledTexImageUnit
= -1;
731 ctx
->Texture
._EnabledCoordUnits
= 0x0;
733 memset(&enabled_texture_units
, 0, sizeof(enabled_texture_units
));
735 /* First, walk over our programs pulling in all the textures for them.
736 * Programs dictate specific texture targets to be enabled, and for a draw
737 * call to be valid they can't conflict about which texture targets are
740 update_program_texture_state(ctx
, prog
, enabled_texture_units
);
742 /* Also pull in any textures necessary for fixed function fragment shading.
744 if (!prog
[MESA_SHADER_FRAGMENT
])
745 update_ff_texture_state(ctx
, enabled_texture_units
);
747 /* Now, clear out the _Current of any disabled texture units. */
748 for (i
= 0; i
<= ctx
->Texture
._MaxEnabledTexImageUnit
; i
++) {
749 if (!BITSET_TEST(enabled_texture_units
, i
))
750 _mesa_reference_texobj(&ctx
->Texture
.Unit
[i
]._Current
, NULL
);
752 for (i
= ctx
->Texture
._MaxEnabledTexImageUnit
+ 1; i
<= old_max_unit
; i
++) {
753 _mesa_reference_texobj(&ctx
->Texture
.Unit
[i
]._Current
, NULL
);
756 if (!prog
[MESA_SHADER_FRAGMENT
] || !prog
[MESA_SHADER_VERTEX
])
759 _mesa_validate_image_units(ctx
);
764 * Update texture-related derived state.
767 _mesa_update_texture( struct gl_context
*ctx
, GLuint new_state
)
769 if (new_state
& _NEW_TEXTURE_MATRIX
)
770 update_texture_matrices( ctx
);
772 if (new_state
& (_NEW_TEXTURE
| _NEW_PROGRAM
))
773 update_texture_state( ctx
);
777 /**********************************************************************/
778 /***** Initialization *****/
779 /**********************************************************************/
782 * Allocate the proxy textures for the given context.
784 * \param ctx the context to allocate proxies for.
786 * \return GL_TRUE on success, or GL_FALSE on failure
788 * If run out of memory part way through the allocations, clean up and return
792 alloc_proxy_textures( struct gl_context
*ctx
)
794 /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
797 static const GLenum targets
[] = {
798 GL_TEXTURE_2D_MULTISAMPLE
,
799 GL_TEXTURE_2D_MULTISAMPLE_ARRAY
,
800 GL_TEXTURE_CUBE_MAP_ARRAY
,
802 GL_TEXTURE_2D_ARRAY_EXT
,
803 GL_TEXTURE_1D_ARRAY_EXT
,
804 GL_TEXTURE_EXTERNAL_OES
,
805 GL_TEXTURE_CUBE_MAP_ARB
,
807 GL_TEXTURE_RECTANGLE_NV
,
813 STATIC_ASSERT(Elements(targets
) == NUM_TEXTURE_TARGETS
);
814 assert(targets
[TEXTURE_2D_INDEX
] == GL_TEXTURE_2D
);
815 assert(targets
[TEXTURE_CUBE_INDEX
] == GL_TEXTURE_CUBE_MAP
);
817 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++) {
818 if (!(ctx
->Texture
.ProxyTex
[tgt
]
819 = ctx
->Driver
.NewTextureObject(ctx
, 0, targets
[tgt
]))) {
820 /* out of memory, free what we did allocate */
822 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
828 assert(ctx
->Texture
.ProxyTex
[0]->RefCount
== 1); /* sanity check */
834 * Initialize a texture unit.
836 * \param ctx GL context.
837 * \param unit texture unit number to be initialized.
840 init_texture_unit( struct gl_context
*ctx
, GLuint unit
)
842 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
845 texUnit
->EnvMode
= GL_MODULATE
;
846 ASSIGN_4V( texUnit
->EnvColor
, 0.0, 0.0, 0.0, 0.0 );
848 texUnit
->Combine
= default_combine_state
;
849 texUnit
->_EnvMode
= default_combine_state
;
850 texUnit
->_CurrentCombine
= & texUnit
->_EnvMode
;
851 texUnit
->BumpTarget
= GL_TEXTURE0
;
853 texUnit
->TexGenEnabled
= 0x0;
854 texUnit
->GenS
.Mode
= GL_EYE_LINEAR
;
855 texUnit
->GenT
.Mode
= GL_EYE_LINEAR
;
856 texUnit
->GenR
.Mode
= GL_EYE_LINEAR
;
857 texUnit
->GenQ
.Mode
= GL_EYE_LINEAR
;
858 texUnit
->GenS
._ModeBit
= TEXGEN_EYE_LINEAR
;
859 texUnit
->GenT
._ModeBit
= TEXGEN_EYE_LINEAR
;
860 texUnit
->GenR
._ModeBit
= TEXGEN_EYE_LINEAR
;
861 texUnit
->GenQ
._ModeBit
= TEXGEN_EYE_LINEAR
;
863 /* Yes, these plane coefficients are correct! */
864 ASSIGN_4V( texUnit
->GenS
.ObjectPlane
, 1.0, 0.0, 0.0, 0.0 );
865 ASSIGN_4V( texUnit
->GenT
.ObjectPlane
, 0.0, 1.0, 0.0, 0.0 );
866 ASSIGN_4V( texUnit
->GenR
.ObjectPlane
, 0.0, 0.0, 0.0, 0.0 );
867 ASSIGN_4V( texUnit
->GenQ
.ObjectPlane
, 0.0, 0.0, 0.0, 0.0 );
868 ASSIGN_4V( texUnit
->GenS
.EyePlane
, 1.0, 0.0, 0.0, 0.0 );
869 ASSIGN_4V( texUnit
->GenT
.EyePlane
, 0.0, 1.0, 0.0, 0.0 );
870 ASSIGN_4V( texUnit
->GenR
.EyePlane
, 0.0, 0.0, 0.0, 0.0 );
871 ASSIGN_4V( texUnit
->GenQ
.EyePlane
, 0.0, 0.0, 0.0, 0.0 );
873 /* no mention of this in spec, but maybe id matrix expected? */
874 ASSIGN_4V( texUnit
->RotMatrix
, 1.0, 0.0, 0.0, 1.0 );
876 /* initialize current texture object ptrs to the shared default objects */
877 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
878 _mesa_reference_texobj(&texUnit
->CurrentTex
[tex
],
879 ctx
->Shared
->DefaultTex
[tex
]);
882 texUnit
->_BoundTextures
= 0;
887 * Initialize texture state for the given context.
890 _mesa_init_texture(struct gl_context
*ctx
)
895 ctx
->Texture
.CurrentUnit
= 0; /* multitexture */
897 /* Appendix F.2 of the OpenGL ES 3.0 spec says:
899 * "OpenGL ES 3.0 requires that all cube map filtering be
900 * seamless. OpenGL ES 2.0 specified that a single cube map face be
901 * selected and used for filtering."
903 ctx
->Texture
.CubeMapSeamless
= _mesa_is_gles3(ctx
);
905 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++)
906 init_texture_unit(ctx
, u
);
908 /* After we're done initializing the context's texture state the default
909 * texture objects' refcounts should be at least
910 * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
912 assert(ctx
->Shared
->DefaultTex
[TEXTURE_1D_INDEX
]->RefCount
913 >= MAX_COMBINED_TEXTURE_IMAGE_UNITS
+ 1);
915 /* Allocate proxy textures */
916 if (!alloc_proxy_textures( ctx
))
919 /* GL_ARB_texture_buffer_object */
920 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
,
921 ctx
->Shared
->NullBufferObj
);
923 ctx
->Texture
.NumCurrentTexUsed
= 0;
930 * Free dynamically-allocted texture data attached to the given context.
933 _mesa_free_texture_data(struct gl_context
*ctx
)
937 /* unreference current textures */
938 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
939 /* The _Current texture could account for another reference */
940 _mesa_reference_texobj(&ctx
->Texture
.Unit
[u
]._Current
, NULL
);
942 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++) {
943 _mesa_reference_texobj(&ctx
->Texture
.Unit
[u
].CurrentTex
[tgt
], NULL
);
947 /* Free proxy texture objects */
948 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++)
949 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
951 /* GL_ARB_texture_buffer_object */
952 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
, NULL
);
954 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
955 _mesa_reference_sampler_object(ctx
, &ctx
->Texture
.Unit
[u
].Sampler
, NULL
);
961 * Update the default texture objects in the given context to reference those
962 * specified in the shared state and release those referencing the old
966 _mesa_update_default_objects_texture(struct gl_context
*ctx
)
970 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
971 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[u
];
972 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
973 _mesa_reference_texobj(&texUnit
->CurrentTex
[tex
],
974 ctx
->Shared
->DefaultTex
[tex
]);