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"
46 * Default texture combine environment state. This is used to initialize
47 * a context's texture units and as the basis for converting "classic"
48 * texture environmnets to ARB_texture_env_combine style values.
50 static const struct gl_tex_env_combine_state default_combine_state
= {
51 GL_MODULATE
, GL_MODULATE
,
52 { GL_TEXTURE
, GL_PREVIOUS
, GL_CONSTANT
, GL_CONSTANT
},
53 { GL_TEXTURE
, GL_PREVIOUS
, GL_CONSTANT
, GL_CONSTANT
},
54 { GL_SRC_COLOR
, GL_SRC_COLOR
, GL_SRC_ALPHA
, GL_SRC_ALPHA
},
55 { GL_SRC_ALPHA
, GL_SRC_ALPHA
, GL_SRC_ALPHA
, GL_SRC_ALPHA
},
63 * Used by glXCopyContext to copy texture state from one context to another.
66 _mesa_copy_texture_state( const struct gl_context
*src
, struct gl_context
*dst
)
73 dst
->Texture
.CurrentUnit
= src
->Texture
.CurrentUnit
;
74 dst
->Texture
._GenFlags
= src
->Texture
._GenFlags
;
75 dst
->Texture
._TexGenEnabled
= src
->Texture
._TexGenEnabled
;
76 dst
->Texture
._TexMatEnabled
= src
->Texture
._TexMatEnabled
;
79 for (u
= 0; u
< src
->Const
.MaxCombinedTextureImageUnits
; u
++) {
80 dst
->Texture
.Unit
[u
].Enabled
= src
->Texture
.Unit
[u
].Enabled
;
81 dst
->Texture
.Unit
[u
].EnvMode
= src
->Texture
.Unit
[u
].EnvMode
;
82 COPY_4V(dst
->Texture
.Unit
[u
].EnvColor
, src
->Texture
.Unit
[u
].EnvColor
);
83 dst
->Texture
.Unit
[u
].TexGenEnabled
= src
->Texture
.Unit
[u
].TexGenEnabled
;
84 dst
->Texture
.Unit
[u
].GenS
= src
->Texture
.Unit
[u
].GenS
;
85 dst
->Texture
.Unit
[u
].GenT
= src
->Texture
.Unit
[u
].GenT
;
86 dst
->Texture
.Unit
[u
].GenR
= src
->Texture
.Unit
[u
].GenR
;
87 dst
->Texture
.Unit
[u
].GenQ
= src
->Texture
.Unit
[u
].GenQ
;
88 dst
->Texture
.Unit
[u
].LodBias
= src
->Texture
.Unit
[u
].LodBias
;
90 /* GL_EXT_texture_env_combine */
91 dst
->Texture
.Unit
[u
].Combine
= src
->Texture
.Unit
[u
].Combine
;
93 /* GL_ATI_envmap_bumpmap - need this? */
94 dst
->Texture
.Unit
[u
].BumpTarget
= src
->Texture
.Unit
[u
].BumpTarget
;
95 COPY_4V(dst
->Texture
.Unit
[u
].RotMatrix
, src
->Texture
.Unit
[u
].RotMatrix
);
98 * XXX strictly speaking, we should compare texture names/ids and
99 * bind textures in the dest context according to id. For now, only
100 * copy bindings if the contexts share the same pool of textures to
101 * avoid refcounting bugs.
103 if (dst
->Shared
== src
->Shared
) {
104 /* copy texture object bindings, not contents of texture objects */
105 _mesa_lock_context_textures(dst
);
107 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
108 _mesa_reference_texobj(&dst
->Texture
.Unit
[u
].CurrentTex
[tex
],
109 src
->Texture
.Unit
[u
].CurrentTex
[tex
]);
111 _mesa_unlock_context_textures(dst
);
121 _mesa_print_texunit_state( struct gl_context
*ctx
, GLuint unit
)
123 const struct gl_texture_unit
*texUnit
= ctx
->Texture
.Unit
+ unit
;
124 printf("Texture Unit %d\n", unit
);
125 printf(" GL_TEXTURE_ENV_MODE = %s\n", _mesa_lookup_enum_by_nr(texUnit
->EnvMode
));
126 printf(" GL_COMBINE_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.ModeRGB
));
127 printf(" GL_COMBINE_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.ModeA
));
128 printf(" GL_SOURCE0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[0]));
129 printf(" GL_SOURCE1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[1]));
130 printf(" GL_SOURCE2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceRGB
[2]));
131 printf(" GL_SOURCE0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[0]));
132 printf(" GL_SOURCE1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[1]));
133 printf(" GL_SOURCE2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.SourceA
[2]));
134 printf(" GL_OPERAND0_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[0]));
135 printf(" GL_OPERAND1_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[1]));
136 printf(" GL_OPERAND2_RGB = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandRGB
[2]));
137 printf(" GL_OPERAND0_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[0]));
138 printf(" GL_OPERAND1_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[1]));
139 printf(" GL_OPERAND2_ALPHA = %s\n", _mesa_lookup_enum_by_nr(texUnit
->Combine
.OperandA
[2]));
140 printf(" GL_RGB_SCALE = %d\n", 1 << texUnit
->Combine
.ScaleShiftRGB
);
141 printf(" GL_ALPHA_SCALE = %d\n", 1 << texUnit
->Combine
.ScaleShiftA
);
142 printf(" GL_TEXTURE_ENV_COLOR = (%f, %f, %f, %f)\n", texUnit
->EnvColor
[0], texUnit
->EnvColor
[1], texUnit
->EnvColor
[2], texUnit
->EnvColor
[3]);
147 /**********************************************************************/
148 /* Texture Environment */
149 /**********************************************************************/
152 * Convert "classic" texture environment to ARB_texture_env_combine style
155 * \param state texture_env_combine state vector to be filled-in.
156 * \param mode Classic texture environment mode (i.e., \c GL_REPLACE,
157 * \c GL_BLEND, \c GL_DECAL, etc.).
158 * \param texBaseFormat Base format of the texture associated with the
162 calculate_derived_texenv( struct gl_tex_env_combine_state
*state
,
163 GLenum mode
, GLenum texBaseFormat
)
168 *state
= default_combine_state
;
170 switch (texBaseFormat
) {
172 state
->SourceRGB
[0] = GL_PREVIOUS
;
175 case GL_LUMINANCE_ALPHA
:
186 state
->SourceA
[0] = GL_PREVIOUS
;
191 "Invalid texBaseFormat 0x%x in calculate_derived_texenv",
196 if (mode
== GL_REPLACE_EXT
)
202 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: mode
;
207 mode_rgb
= GL_INTERPOLATE
;
210 state
->SourceA
[0] = GL_PREVIOUS
;
212 /* Having alpha / luminance / intensity textures replace using the
213 * incoming fragment color matches the definition in NV_texture_shader.
214 * The 1.5 spec simply marks these as "undefined".
216 switch (texBaseFormat
) {
219 case GL_LUMINANCE_ALPHA
:
221 state
->SourceRGB
[0] = GL_PREVIOUS
;
228 mode_rgb
= GL_REPLACE
;
231 state
->SourceRGB
[2] = GL_TEXTURE
;
237 mode_rgb
= GL_INTERPOLATE
;
238 mode_a
= GL_MODULATE
;
240 switch (texBaseFormat
) {
242 mode_rgb
= GL_REPLACE
;
245 mode_a
= GL_INTERPOLATE
;
246 state
->SourceA
[0] = GL_CONSTANT
;
247 state
->OperandA
[2] = GL_SRC_ALPHA
;
253 case GL_LUMINANCE_ALPHA
:
257 state
->SourceRGB
[2] = GL_TEXTURE
;
258 state
->SourceA
[2] = GL_TEXTURE
;
259 state
->SourceRGB
[0] = GL_CONSTANT
;
260 state
->OperandRGB
[2] = GL_SRC_COLOR
;
266 mode_rgb
= (texBaseFormat
== GL_ALPHA
) ? GL_REPLACE
: GL_ADD
;
267 mode_a
= (texBaseFormat
== GL_INTENSITY
) ? GL_ADD
: GL_MODULATE
;
272 "Invalid texture env mode 0x%x in calculate_derived_texenv",
277 state
->ModeRGB
= (state
->SourceRGB
[0] != GL_PREVIOUS
)
278 ? mode_rgb
: GL_REPLACE
;
279 state
->ModeA
= (state
->SourceA
[0] != GL_PREVIOUS
)
280 ? mode_a
: GL_REPLACE
;
286 /* GL_ARB_multitexture */
288 _mesa_ActiveTexture(GLenum texture
)
290 const GLuint texUnit
= texture
- GL_TEXTURE0
;
292 GET_CURRENT_CONTEXT(ctx
);
294 /* See OpenGL spec for glActiveTexture: */
295 k
= MAX2(ctx
->Const
.MaxCombinedTextureImageUnits
,
296 ctx
->Const
.MaxTextureCoordUnits
);
298 ASSERT(k
<= Elements(ctx
->Texture
.Unit
));
300 if (MESA_VERBOSE
& (VERBOSE_API
|VERBOSE_TEXTURE
))
301 _mesa_debug(ctx
, "glActiveTexture %s\n",
302 _mesa_lookup_enum_by_nr(texture
));
305 _mesa_error(ctx
, GL_INVALID_ENUM
, "glActiveTexture(texture=%s)",
306 _mesa_lookup_enum_by_nr(texture
));
310 if (ctx
->Texture
.CurrentUnit
== texUnit
)
313 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
);
315 ctx
->Texture
.CurrentUnit
= texUnit
;
316 if (ctx
->Transform
.MatrixMode
== GL_TEXTURE
) {
317 /* update current stack pointer */
318 ctx
->CurrentStack
= &ctx
->TextureMatrixStack
[texUnit
];
323 /* GL_ARB_multitexture */
325 _mesa_ClientActiveTexture(GLenum texture
)
327 GET_CURRENT_CONTEXT(ctx
);
328 GLuint texUnit
= texture
- GL_TEXTURE0
;
330 if (MESA_VERBOSE
& (VERBOSE_API
| VERBOSE_TEXTURE
))
331 _mesa_debug(ctx
, "glClientActiveTexture %s\n",
332 _mesa_lookup_enum_by_nr(texture
));
334 if (texUnit
>= ctx
->Const
.MaxTextureCoordUnits
) {
335 _mesa_error(ctx
, GL_INVALID_ENUM
, "glClientActiveTexture(texture)");
339 if (ctx
->Array
.ActiveTexture
== texUnit
)
342 FLUSH_VERTICES(ctx
, _NEW_ARRAY
);
343 ctx
->Array
.ActiveTexture
= texUnit
;
348 /**********************************************************************/
349 /***** State management *****/
350 /**********************************************************************/
354 * \note This routine refers to derived texture attribute values to
355 * compute the ENABLE_TEXMAT flags, but is only called on
356 * _NEW_TEXTURE_MATRIX. On changes to _NEW_TEXTURE, the ENABLE_TEXMAT
357 * flags are updated by _mesa_update_textures(), below.
359 * \param ctx GL context.
362 update_texture_matrices( struct gl_context
*ctx
)
366 ctx
->Texture
._TexMatEnabled
= 0x0;
368 for (u
= 0; u
< ctx
->Const
.MaxTextureCoordUnits
; u
++) {
369 ASSERT(u
< Elements(ctx
->TextureMatrixStack
));
370 if (_math_matrix_is_dirty(ctx
->TextureMatrixStack
[u
].Top
)) {
371 _math_matrix_analyse( ctx
->TextureMatrixStack
[u
].Top
);
373 if (ctx
->Texture
.Unit
[u
]._ReallyEnabled
&&
374 ctx
->TextureMatrixStack
[u
].Top
->type
!= MATRIX_IDENTITY
)
375 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(u
);
382 * Examine texture unit's combine/env state to update derived state.
385 update_tex_combine(struct gl_context
*ctx
, struct gl_texture_unit
*texUnit
)
387 struct gl_tex_env_combine_state
*combine
;
389 /* No combiners will apply to this. */
390 if (texUnit
->_Current
->Target
== GL_TEXTURE_BUFFER
)
393 /* Set the texUnit->_CurrentCombine field to point to the user's combiner
394 * state, or the combiner state which is derived from traditional texenv
397 if (texUnit
->EnvMode
== GL_COMBINE
||
398 texUnit
->EnvMode
== GL_COMBINE4_NV
) {
399 texUnit
->_CurrentCombine
= & texUnit
->Combine
;
402 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
403 GLenum format
= texObj
->Image
[0][texObj
->BaseLevel
]->_BaseFormat
;
405 if (format
== GL_DEPTH_COMPONENT
|| format
== GL_DEPTH_STENCIL_EXT
) {
406 format
= texObj
->DepthMode
;
408 calculate_derived_texenv(&texUnit
->_EnvMode
, texUnit
->EnvMode
, format
);
409 texUnit
->_CurrentCombine
= & texUnit
->_EnvMode
;
412 combine
= texUnit
->_CurrentCombine
;
414 /* Determine number of source RGB terms in the combiner function */
415 switch (combine
->ModeRGB
) {
417 combine
->_NumArgsRGB
= 1;
421 if (texUnit
->EnvMode
== GL_COMBINE4_NV
)
422 combine
->_NumArgsRGB
= 4;
424 combine
->_NumArgsRGB
= 2;
430 case GL_DOT3_RGB_EXT
:
431 case GL_DOT3_RGBA_EXT
:
432 combine
->_NumArgsRGB
= 2;
435 case GL_MODULATE_ADD_ATI
:
436 case GL_MODULATE_SIGNED_ADD_ATI
:
437 case GL_MODULATE_SUBTRACT_ATI
:
438 combine
->_NumArgsRGB
= 3;
440 case GL_BUMP_ENVMAP_ATI
:
441 /* no real arguments for this case */
442 combine
->_NumArgsRGB
= 0;
445 combine
->_NumArgsRGB
= 0;
446 _mesa_problem(ctx
, "invalid RGB combine mode in update_texture_state");
450 /* Determine number of source Alpha terms in the combiner function */
451 switch (combine
->ModeA
) {
453 combine
->_NumArgsA
= 1;
457 if (texUnit
->EnvMode
== GL_COMBINE4_NV
)
458 combine
->_NumArgsA
= 4;
460 combine
->_NumArgsA
= 2;
464 combine
->_NumArgsA
= 2;
467 case GL_MODULATE_ADD_ATI
:
468 case GL_MODULATE_SIGNED_ADD_ATI
:
469 case GL_MODULATE_SUBTRACT_ATI
:
470 combine
->_NumArgsA
= 3;
473 combine
->_NumArgsA
= 0;
474 _mesa_problem(ctx
, "invalid Alpha combine mode in update_texture_state");
480 update_texgen(struct gl_context
*ctx
)
484 /* Setup texgen for those texture coordinate sets that are in use */
485 for (unit
= 0; unit
< ctx
->Const
.MaxTextureCoordUnits
; unit
++) {
486 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
488 texUnit
->_GenFlags
= 0x0;
490 if (!(ctx
->Texture
._EnabledCoordUnits
& (1 << unit
)))
493 if (texUnit
->TexGenEnabled
) {
494 if (texUnit
->TexGenEnabled
& S_BIT
) {
495 texUnit
->_GenFlags
|= texUnit
->GenS
._ModeBit
;
497 if (texUnit
->TexGenEnabled
& T_BIT
) {
498 texUnit
->_GenFlags
|= texUnit
->GenT
._ModeBit
;
500 if (texUnit
->TexGenEnabled
& R_BIT
) {
501 texUnit
->_GenFlags
|= texUnit
->GenR
._ModeBit
;
503 if (texUnit
->TexGenEnabled
& Q_BIT
) {
504 texUnit
->_GenFlags
|= texUnit
->GenQ
._ModeBit
;
507 ctx
->Texture
._TexGenEnabled
|= ENABLE_TEXGEN(unit
);
508 ctx
->Texture
._GenFlags
|= texUnit
->_GenFlags
;
511 ASSERT(unit
< Elements(ctx
->TextureMatrixStack
));
512 if (ctx
->TextureMatrixStack
[unit
].Top
->type
!= MATRIX_IDENTITY
)
513 ctx
->Texture
._TexMatEnabled
|= ENABLE_TEXMAT(unit
);
518 * \note This routine refers to derived texture matrix values to
519 * compute the ENABLE_TEXMAT flags, but is only called on
520 * _NEW_TEXTURE. On changes to _NEW_TEXTURE_MATRIX, the ENABLE_TEXMAT
521 * flags are updated by _mesa_update_texture_matrices, above.
523 * \param ctx GL context.
526 update_texture_state( struct gl_context
*ctx
)
529 struct gl_program
*fprog
= NULL
;
530 struct gl_program
*vprog
= NULL
;
531 struct gl_program
*gprog
= NULL
;
532 GLbitfield enabledFragUnits
= 0x0;
534 if (ctx
->Shader
.CurrentVertexProgram
&&
535 ctx
->Shader
.CurrentVertexProgram
->LinkStatus
) {
536 vprog
= ctx
->Shader
.CurrentVertexProgram
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
;
539 if (ctx
->Shader
.CurrentGeometryProgram
&&
540 ctx
->Shader
.CurrentGeometryProgram
->LinkStatus
) {
541 gprog
= ctx
->Shader
.CurrentGeometryProgram
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
;
544 if (ctx
->Shader
.CurrentFragmentProgram
&&
545 ctx
->Shader
.CurrentFragmentProgram
->LinkStatus
) {
546 fprog
= ctx
->Shader
.CurrentFragmentProgram
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
;
548 else if (ctx
->FragmentProgram
._Enabled
) {
549 fprog
= &ctx
->FragmentProgram
.Current
->Base
;
552 /* TODO: only set this if there are actual changes */
553 ctx
->NewState
|= _NEW_TEXTURE
;
555 ctx
->Texture
._EnabledUnits
= 0x0;
556 ctx
->Texture
._GenFlags
= 0x0;
557 ctx
->Texture
._TexMatEnabled
= 0x0;
558 ctx
->Texture
._TexGenEnabled
= 0x0;
561 * Update texture unit state.
563 for (unit
= 0; unit
< ctx
->Const
.MaxCombinedTextureImageUnits
; unit
++) {
564 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
565 GLbitfield enabledVertTargets
= 0x0;
566 GLbitfield enabledFragTargets
= 0x0;
567 GLbitfield enabledGeomTargets
= 0x0;
568 GLbitfield enabledTargets
= 0x0;
571 /* Get the bitmask of texture target enables.
572 * enableBits will be a mask of the TEXTURE_*_BIT flags indicating
573 * which texture targets are enabled (fixed function) or referenced
574 * by a fragment program/program. When multiple flags are set, we'll
575 * settle on the one with highest priority (see below).
578 enabledVertTargets
|= vprog
->TexturesUsed
[unit
];
582 enabledGeomTargets
|= gprog
->TexturesUsed
[unit
];
586 enabledFragTargets
|= fprog
->TexturesUsed
[unit
];
589 /* fixed-function fragment program */
590 enabledFragTargets
|= texUnit
->Enabled
;
593 enabledTargets
= enabledVertTargets
| enabledFragTargets
|
596 texUnit
->_ReallyEnabled
= 0x0;
598 if (enabledTargets
== 0x0) {
599 /* neither vertex nor fragment processing uses this unit */
603 /* Look for the highest priority texture target that's enabled (or used
604 * by the vert/frag shaders) and "complete". That's the one we'll use
607 * Note that the TEXTURE_x_INDEX values are in high to low priority.
609 for (texIndex
= 0; texIndex
< NUM_TEXTURE_TARGETS
; texIndex
++) {
610 if (enabledTargets
& (1 << texIndex
)) {
611 struct gl_texture_object
*texObj
= texUnit
->CurrentTex
[texIndex
];
612 struct gl_sampler_object
*sampler
= texUnit
->Sampler
?
613 texUnit
->Sampler
: &texObj
->Sampler
;
615 if (!_mesa_is_texture_complete(texObj
, sampler
)) {
616 _mesa_test_texobj_completeness(ctx
, texObj
);
618 if (_mesa_is_texture_complete(texObj
, sampler
)) {
619 texUnit
->_ReallyEnabled
= 1 << texIndex
;
620 _mesa_reference_texobj(&texUnit
->_Current
, texObj
);
626 if (!texUnit
->_ReallyEnabled
) {
628 /* If we get here it means the shader is expecting a texture
629 * object, but there isn't one (or it's incomplete). Use the
632 struct gl_texture_object
*texObj
;
633 gl_texture_index texTarget
;
635 texTarget
= (gl_texture_index
) (ffs(enabledTargets
) - 1);
636 texObj
= _mesa_get_fallback_texture(ctx
, texTarget
);
640 /* invalid fallback texture: don't enable the texture unit */
644 _mesa_reference_texobj(&texUnit
->_Current
, texObj
);
645 texUnit
->_ReallyEnabled
= 1 << texTarget
;
648 /* fixed-function: texture unit is really disabled */
653 /* if we get here, we know this texture unit is enabled */
655 ctx
->Texture
._EnabledUnits
|= (1 << unit
);
657 if (enabledFragTargets
)
658 enabledFragUnits
|= (1 << unit
);
661 update_tex_combine(ctx
, texUnit
);
665 /* Determine which texture coordinate sets are actually needed */
667 const GLuint coordMask
= (1 << MAX_TEXTURE_COORD_UNITS
) - 1;
668 ctx
->Texture
._EnabledCoordUnits
669 = (fprog
->InputsRead
>> VARYING_SLOT_TEX0
) & coordMask
;
672 ctx
->Texture
._EnabledCoordUnits
= enabledFragUnits
;
675 if (!fprog
|| !vprog
)
681 * Update texture-related derived state.
684 _mesa_update_texture( struct gl_context
*ctx
, GLuint new_state
)
686 if (new_state
& _NEW_TEXTURE_MATRIX
)
687 update_texture_matrices( ctx
);
689 if (new_state
& (_NEW_TEXTURE
| _NEW_PROGRAM
))
690 update_texture_state( ctx
);
694 /**********************************************************************/
695 /***** Initialization *****/
696 /**********************************************************************/
699 * Allocate the proxy textures for the given context.
701 * \param ctx the context to allocate proxies for.
703 * \return GL_TRUE on success, or GL_FALSE on failure
705 * If run out of memory part way through the allocations, clean up and return
709 alloc_proxy_textures( struct gl_context
*ctx
)
711 /* NOTE: these values must be in the same order as the TEXTURE_x_INDEX
714 static const GLenum targets
[] = {
715 GL_TEXTURE_2D_MULTISAMPLE
,
716 GL_TEXTURE_2D_MULTISAMPLE_ARRAY
,
717 GL_TEXTURE_CUBE_MAP_ARRAY
,
719 GL_TEXTURE_2D_ARRAY_EXT
,
720 GL_TEXTURE_1D_ARRAY_EXT
,
721 GL_TEXTURE_EXTERNAL_OES
,
722 GL_TEXTURE_CUBE_MAP_ARB
,
724 GL_TEXTURE_RECTANGLE_NV
,
730 STATIC_ASSERT(Elements(targets
) == NUM_TEXTURE_TARGETS
);
731 assert(targets
[TEXTURE_2D_INDEX
] == GL_TEXTURE_2D
);
732 assert(targets
[TEXTURE_CUBE_INDEX
] == GL_TEXTURE_CUBE_MAP
);
734 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++) {
735 if (!(ctx
->Texture
.ProxyTex
[tgt
]
736 = ctx
->Driver
.NewTextureObject(ctx
, 0, targets
[tgt
]))) {
737 /* out of memory, free what we did allocate */
739 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
745 assert(ctx
->Texture
.ProxyTex
[0]->RefCount
== 1); /* sanity check */
751 * Initialize a texture unit.
753 * \param ctx GL context.
754 * \param unit texture unit number to be initialized.
757 init_texture_unit( struct gl_context
*ctx
, GLuint unit
)
759 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
762 texUnit
->EnvMode
= GL_MODULATE
;
763 ASSIGN_4V( texUnit
->EnvColor
, 0.0, 0.0, 0.0, 0.0 );
765 texUnit
->Combine
= default_combine_state
;
766 texUnit
->_EnvMode
= default_combine_state
;
767 texUnit
->_CurrentCombine
= & texUnit
->_EnvMode
;
768 texUnit
->BumpTarget
= GL_TEXTURE0
;
770 texUnit
->TexGenEnabled
= 0x0;
771 texUnit
->GenS
.Mode
= GL_EYE_LINEAR
;
772 texUnit
->GenT
.Mode
= GL_EYE_LINEAR
;
773 texUnit
->GenR
.Mode
= GL_EYE_LINEAR
;
774 texUnit
->GenQ
.Mode
= GL_EYE_LINEAR
;
775 texUnit
->GenS
._ModeBit
= TEXGEN_EYE_LINEAR
;
776 texUnit
->GenT
._ModeBit
= TEXGEN_EYE_LINEAR
;
777 texUnit
->GenR
._ModeBit
= TEXGEN_EYE_LINEAR
;
778 texUnit
->GenQ
._ModeBit
= TEXGEN_EYE_LINEAR
;
780 /* Yes, these plane coefficients are correct! */
781 ASSIGN_4V( texUnit
->GenS
.ObjectPlane
, 1.0, 0.0, 0.0, 0.0 );
782 ASSIGN_4V( texUnit
->GenT
.ObjectPlane
, 0.0, 1.0, 0.0, 0.0 );
783 ASSIGN_4V( texUnit
->GenR
.ObjectPlane
, 0.0, 0.0, 0.0, 0.0 );
784 ASSIGN_4V( texUnit
->GenQ
.ObjectPlane
, 0.0, 0.0, 0.0, 0.0 );
785 ASSIGN_4V( texUnit
->GenS
.EyePlane
, 1.0, 0.0, 0.0, 0.0 );
786 ASSIGN_4V( texUnit
->GenT
.EyePlane
, 0.0, 1.0, 0.0, 0.0 );
787 ASSIGN_4V( texUnit
->GenR
.EyePlane
, 0.0, 0.0, 0.0, 0.0 );
788 ASSIGN_4V( texUnit
->GenQ
.EyePlane
, 0.0, 0.0, 0.0, 0.0 );
790 /* no mention of this in spec, but maybe id matrix expected? */
791 ASSIGN_4V( texUnit
->RotMatrix
, 1.0, 0.0, 0.0, 1.0 );
793 /* initialize current texture object ptrs to the shared default objects */
794 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
795 _mesa_reference_texobj(&texUnit
->CurrentTex
[tex
],
796 ctx
->Shared
->DefaultTex
[tex
]);
802 * Initialize texture state for the given context.
805 _mesa_init_texture(struct gl_context
*ctx
)
810 ctx
->Texture
.CurrentUnit
= 0; /* multitexture */
811 ctx
->Texture
._EnabledUnits
= 0x0;
813 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++)
814 init_texture_unit(ctx
, u
);
816 /* After we're done initializing the context's texture state the default
817 * texture objects' refcounts should be at least
818 * MAX_COMBINED_TEXTURE_IMAGE_UNITS + 1.
820 assert(ctx
->Shared
->DefaultTex
[TEXTURE_1D_INDEX
]->RefCount
821 >= MAX_COMBINED_TEXTURE_IMAGE_UNITS
+ 1);
823 /* Allocate proxy textures */
824 if (!alloc_proxy_textures( ctx
))
827 /* GL_ARB_texture_buffer_object */
828 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
,
829 ctx
->Shared
->NullBufferObj
);
836 * Free dynamically-allocted texture data attached to the given context.
839 _mesa_free_texture_data(struct gl_context
*ctx
)
843 /* unreference current textures */
844 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
845 /* The _Current texture could account for another reference */
846 _mesa_reference_texobj(&ctx
->Texture
.Unit
[u
]._Current
, NULL
);
848 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++) {
849 _mesa_reference_texobj(&ctx
->Texture
.Unit
[u
].CurrentTex
[tgt
], NULL
);
853 /* Free proxy texture objects */
854 for (tgt
= 0; tgt
< NUM_TEXTURE_TARGETS
; tgt
++)
855 ctx
->Driver
.DeleteTexture(ctx
, ctx
->Texture
.ProxyTex
[tgt
]);
857 /* GL_ARB_texture_buffer_object */
858 _mesa_reference_buffer_object(ctx
, &ctx
->Texture
.BufferObject
, NULL
);
860 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
861 _mesa_reference_sampler_object(ctx
, &ctx
->Texture
.Unit
[u
].Sampler
, NULL
);
867 * Update the default texture objects in the given context to reference those
868 * specified in the shared state and release those referencing the old
872 _mesa_update_default_objects_texture(struct gl_context
*ctx
)
876 for (u
= 0; u
< Elements(ctx
->Texture
.Unit
); u
++) {
877 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[u
];
878 for (tex
= 0; tex
< NUM_TEXTURE_TARGETS
; tex
++) {
879 _mesa_reference_texobj(&texUnit
->CurrentTex
[tex
],
880 ctx
->Shared
->DefaultTex
[tex
]);