2 * GLX Hardware Device Driver for Intel i810
3 * Copyright (C) 1999 Keith Whitwell
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM,
19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
21 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 #include "main/glheader.h"
26 #include "main/macros.h"
27 #include "main/mtypes.h"
28 #include "main/simple_list.h"
29 #include "main/enums.h"
32 #include "i810screen.h"
35 #include "i810context.h"
37 #include "i810state.h"
38 #include "i810ioctl.h"
43 static void i810SetTexImages( i810ContextPtr imesa
,
44 struct gl_texture_object
*tObj
)
46 GLuint height
, width
, pitch
, i
, textureFormat
, log_pitch
;
47 i810TextureObjectPtr t
= (i810TextureObjectPtr
) tObj
->DriverData
;
48 const struct gl_texture_image
*baseImage
= tObj
->Image
[0][tObj
->BaseLevel
];
50 GLint log2Width
, log2Height
;
52 /* fprintf(stderr, "%s\n", __FUNCTION__); */
55 switch (baseImage
->TexFormat
) {
56 case MESA_FORMAT_ARGB1555
:
57 textureFormat
= MI1_FMT_16BPP
| MI1_PF_16BPP_ARGB1555
;
59 case MESA_FORMAT_ARGB4444
:
60 textureFormat
= MI1_FMT_16BPP
| MI1_PF_16BPP_ARGB4444
;
62 case MESA_FORMAT_RGB565
:
63 textureFormat
= MI1_FMT_16BPP
| MI1_PF_16BPP_RGB565
;
65 case MESA_FORMAT_AL88
:
66 textureFormat
= MI1_FMT_16BPP
| MI1_PF_16BPP_AY88
;
68 case MESA_FORMAT_YCBCR
:
69 textureFormat
= MI1_FMT_422
| MI1_PF_422_YCRCB_SWAP_Y
70 | MI1_COLOR_CONV_ENABLE
;
72 case MESA_FORMAT_YCBCR_REV
:
73 textureFormat
= MI1_FMT_422
| MI1_PF_422_YCRCB
74 | MI1_COLOR_CONV_ENABLE
;
77 textureFormat
= MI1_FMT_8CI
| MI1_PF_8CI_ARGB4444
;
82 fprintf(stderr
, "i810SetTexImages: bad image->Format\n" );
86 driCalculateTextureFirstLastLevel( (driTextureObject
*) t
);
88 numLevels
= t
->base
.lastLevel
- t
->base
.firstLevel
+ 1;
90 log2Width
= tObj
->Image
[0][t
->base
.firstLevel
]->WidthLog2
;
91 log2Height
= tObj
->Image
[0][t
->base
.firstLevel
]->HeightLog2
;
93 /* Figure out the amount of memory required to hold all the mipmap
94 * levels. Choose the smallest pitch to accomodate the largest
97 width
= tObj
->Image
[0][t
->base
.firstLevel
]->Width
* t
->texelBytes
;
98 for (pitch
= 32, log_pitch
=2 ; pitch
< width
; pitch
*= 2 )
101 /* All images must be loaded at this pitch. Count the number of
104 for ( height
= i
= 0 ; i
< numLevels
; i
++ ) {
105 t
->image
[i
].image
= tObj
->Image
[0][t
->base
.firstLevel
+ i
];
106 t
->image
[i
].offset
= height
* pitch
;
107 t
->image
[i
].internalFormat
= baseImage
->_BaseFormat
;
108 height
+= t
->image
[i
].image
->Height
;
112 t
->base
.totalSize
= height
*pitch
;
114 t
->dirty
= I810_UPLOAD_TEX0
| I810_UPLOAD_TEX1
;
115 t
->Setup
[I810_TEXREG_MI1
] = (MI1_MAP_0
| textureFormat
| log_pitch
);
116 t
->Setup
[I810_TEXREG_MLL
] = (GFX_OP_MAP_LOD_LIMITS
|
120 ((numLevels
- 1) << MLL_MIN_MIP_SHIFT
));
122 LOCK_HARDWARE( imesa
);
123 i810UploadTexImagesLocked( imesa
, t
);
124 UNLOCK_HARDWARE( imesa
);
127 /* ================================================================
128 * Texture combine functions
132 static void set_color_stage( unsigned color
, int stage
,
133 i810ContextPtr imesa
)
135 if ( color
!= imesa
->Setup
[I810_CTXREG_MC0
+ stage
] ) {
136 I810_STATECHANGE( imesa
, I810_UPLOAD_CTX
);
137 imesa
->Setup
[I810_CTXREG_MC0
+ stage
] = color
;
142 static void set_alpha_stage( unsigned alpha
, int stage
,
143 i810ContextPtr imesa
)
145 if ( alpha
!= imesa
->Setup
[I810_CTXREG_MA0
+ stage
] ) {
146 I810_STATECHANGE( imesa
, I810_UPLOAD_CTX
);
147 imesa
->Setup
[I810_CTXREG_MA0
+ stage
] = alpha
;
152 static const unsigned operand_modifiers
[] = {
154 MC_ARG_REPLICATE_ALPHA
, MC_ARG_INVERT
| MC_ARG_REPLICATE_ALPHA
158 * Configure the hardware bits for the specified texture environment.
160 * Configures the hardware bits for the texture environment state for the
161 * specified texture unit. As combine stages are added, the values pointed
162 * to by \c color_stage and \c alpha_stage are incremented.
164 * \param ctx GL context pointer.
165 * \param unit Texture unit to be added.
166 * \param color_stage Next available hardware color combine stage.
167 * \param alpha_stage Next available hardware alpha combine stage.
170 * If the combine mode for the specified texture unit could be added without
171 * requiring a software fallback, \c GL_TRUE is returned. Otherwise,
172 * \c GL_FALSE is returned.
175 * If the mode is (GL_REPLACE, GL_PREVIOUS), treat it as though the texture
176 * stage is disabled. That is, don't emit any combine stages.
179 * Add support for ATI_texture_env_combine3 modes. This will require using
180 * two combine stages.
183 * Add support for the missing \c GL_INTERPOLATE modes. This will require
184 * using all three combine stages. There is a comment in the function
185 * describing how this might work.
188 * If, after all the combine stages have been emitted, a texture is never
189 * actually used, disable the texture unit. That should save texture some
190 * memory bandwidth. This won't happen in this function, but this seems like
191 * a reasonable place to make note of it.
194 i810UpdateTexEnvCombine( GLcontext
*ctx
, GLuint unit
,
195 int * color_stage
, int * alpha_stage
)
197 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
198 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
199 GLuint color_arg
[3] = {
200 MC_ARG_ONE
, MC_ARG_ONE
, MC_ARG_ONE
202 GLuint alpha_arg
[3] = {
203 MA_ARG_ITERATED_ALPHA
, MA_ARG_ITERATED_ALPHA
, MA_ARG_ITERATED_ALPHA
206 GLuint color_combine
, alpha_combine
;
207 const GLuint numColorArgs
= texUnit
->_CurrentCombine
->_NumArgsRGB
;
208 const GLuint numAlphaArgs
= texUnit
->_CurrentCombine
->_NumArgsA
;
209 GLuint RGBshift
= texUnit
->_CurrentCombine
->ScaleShiftRGB
;
210 GLuint Ashift
= texUnit
->_CurrentCombine
->ScaleShiftA
;
213 if ( !texUnit
->_ReallyEnabled
) {
218 if ((*color_stage
>= 3) || (*alpha_stage
>= 3)) {
224 * Extract the color and alpha combine function arguments.
227 for ( i
= 0 ; i
< numColorArgs
; i
++ ) {
228 unsigned op
= texUnit
->_CurrentCombine
->OperandRGB
[i
] - GL_SRC_COLOR
;
231 switch ( texUnit
->_CurrentCombine
->SourceRGB
[i
] ) {
233 color_arg
[i
] = MC_ARG_TEX0_COLOR
;
236 color_arg
[i
] = MC_ARG_TEX1_COLOR
;
239 color_arg
[i
] = (unit
== 0)
240 ? MC_ARG_TEX0_COLOR
: MC_ARG_TEX1_COLOR
;
243 color_arg
[i
] = MC_ARG_COLOR_FACTOR
;
245 case GL_PRIMARY_COLOR
:
246 color_arg
[i
] = MC_ARG_ITERATED_COLOR
;
249 color_arg
[i
] = (unit
== 0)
250 ? MC_ARG_ITERATED_COLOR
: MC_ARG_CURRENT_COLOR
;
253 /* Toggle the low bit of the op value. The is the 'invert' bit,
254 * and it acts to convert GL_ZERO+op to the equivalent GL_ONE+op.
261 color_arg
[i
] = MC_ARG_ONE
;
267 color_arg
[i
] |= operand_modifiers
[op
];
271 for ( i
= 0 ; i
< numAlphaArgs
; i
++ ) {
272 unsigned op
= texUnit
->_CurrentCombine
->OperandA
[i
] - GL_SRC_ALPHA
;
275 switch ( texUnit
->_CurrentCombine
->SourceA
[i
] ) {
277 alpha_arg
[i
] = MA_ARG_TEX0_ALPHA
;
280 alpha_arg
[i
] = MA_ARG_TEX1_ALPHA
;
283 alpha_arg
[i
] = (unit
== 0)
284 ? MA_ARG_TEX0_ALPHA
: MA_ARG_TEX1_ALPHA
;
287 alpha_arg
[i
] = MA_ARG_ALPHA_FACTOR
;
289 case GL_PRIMARY_COLOR
:
290 alpha_arg
[i
] = MA_ARG_ITERATED_ALPHA
;
293 alpha_arg
[i
] = (unit
== 0)
294 ? MA_ARG_ITERATED_ALPHA
: MA_ARG_CURRENT_ALPHA
;
297 /* Toggle the low bit of the op value. The is the 'invert' bit,
298 * and it acts to convert GL_ZERO+op to the equivalent GL_ONE+op.
309 alpha_arg
[i
] = MA_ARG_ONE
;
315 alpha_arg
[i
] |= operand_modifiers
[op
];
320 * Build up the color and alpha combine functions.
322 switch ( texUnit
->_CurrentCombine
->ModeRGB
) {
324 color_combine
= MC_OP_ARG1
;
327 color_combine
= MC_OP_MODULATE
+ RGBshift
;
331 color_combine
= MC_OP_ADD
;
334 color_combine
= MC_OP_ADD_SIGNED
;
337 color_combine
= MC_OP_SUBTRACT
;
340 /* For interpolation, the i810 hardware has some limitations. It
341 * can't handle using the secondary or diffuse color (diffuse alpha
342 * is okay) for the third argument.
344 * It is possible to emulate the missing modes by using multiple
345 * combine stages. Unfortunately it requires all three stages to
346 * emulate a single interpolate stage. The (arg0*arg2) portion is
347 * done in stage zero and writes to MC_DEST_ACCUMULATOR. The
348 * (arg1*(1-arg2)) portion is done in stage 1, and the final stage is
349 * (MC_ARG1_ACCUMULATOR | MC_ARG2_CURRENT_COLOR | MC_OP_ADD).
351 * It can also be done without using the accumulator by rearranging
352 * the equation as (arg1 + (arg2 * (arg0 - arg1))). Too bad the i810
353 * doesn't support the MODULATE_AND_ADD mode that the i830 supports.
354 * If it did, the interpolate could be done in only two stages.
357 if ( (color_arg
[2] & MC_ARG_INVERT
) != 0 ) {
358 unsigned temp
= color_arg
[0];
360 color_arg
[0] = color_arg
[1];
362 color_arg
[2] &= ~MC_ARG_INVERT
;
365 switch (color_arg
[2]) {
367 case (MC_ARG_ONE
| MC_ARG_REPLICATE_ALPHA
):
368 color_combine
= MC_OP_ARG1
;
369 color_arg
[1] = MC_ARG_ONE
;
372 case (MC_ARG_COLOR_FACTOR
):
375 case (MC_ARG_COLOR_FACTOR
| MC_ARG_REPLICATE_ALPHA
):
376 color_combine
= MC_OP_LIN_BLEND_ALPHA_FACTOR
;
379 case (MC_ARG_ITERATED_COLOR
):
382 case (MC_ARG_ITERATED_COLOR
| MC_ARG_REPLICATE_ALPHA
):
383 color_combine
= MC_OP_LIN_BLEND_ITER_ALPHA
;
386 case (MC_ARG_SPECULAR_COLOR
):
387 case (MC_ARG_SPECULAR_COLOR
| MC_ARG_REPLICATE_ALPHA
):
390 case (MC_ARG_TEX0_COLOR
):
391 color_combine
= MC_OP_LIN_BLEND_TEX0_COLOR
;
394 case (MC_ARG_TEX0_COLOR
| MC_ARG_REPLICATE_ALPHA
):
395 color_combine
= MC_OP_LIN_BLEND_TEX0_ALPHA
;
398 case (MC_ARG_TEX1_COLOR
):
399 color_combine
= MC_OP_LIN_BLEND_TEX1_COLOR
;
402 case (MC_ARG_TEX1_COLOR
| MC_ARG_REPLICATE_ALPHA
):
403 color_combine
= MC_OP_LIN_BLEND_TEX1_ALPHA
;
416 switch ( texUnit
->_CurrentCombine
->ModeA
) {
418 alpha_combine
= MA_OP_ARG1
;
421 alpha_combine
= MA_OP_MODULATE
+ Ashift
;
425 alpha_combine
= MA_OP_ADD
;
428 alpha_combine
= MA_OP_ADD_SIGNED
;
431 alpha_combine
= MA_OP_SUBTRACT
;
434 if ( (alpha_arg
[2] & MA_ARG_INVERT
) != 0 ) {
435 unsigned temp
= alpha_arg
[0];
437 alpha_arg
[0] = alpha_arg
[1];
439 alpha_arg
[2] &= ~MA_ARG_INVERT
;
442 switch (alpha_arg
[2]) {
444 alpha_combine
= MA_OP_ARG1
;
445 alpha_arg
[1] = MA_ARG_ITERATED_ALPHA
;
448 case MA_ARG_ALPHA_FACTOR
:
449 alpha_combine
= MA_OP_LIN_BLEND_ALPHA_FACTOR
;
452 case MA_ARG_ITERATED_ALPHA
:
453 alpha_combine
= MA_OP_LIN_BLEND_ITER_ALPHA
;
456 case MA_ARG_TEX0_ALPHA
:
457 alpha_combine
= MA_OP_LIN_BLEND_TEX0_ALPHA
;
460 case MA_ARG_TEX1_ALPHA
:
461 alpha_combine
= MA_OP_LIN_BLEND_TEX1_ALPHA
;
474 color_combine
|= GFX_OP_MAP_COLOR_STAGES
| (*color_stage
<< MC_STAGE_SHIFT
)
475 | MC_UPDATE_DEST
| MC_DEST_CURRENT
476 | MC_UPDATE_ARG1
| (color_arg
[0] << MC_ARG1_SHIFT
)
477 | MC_UPDATE_ARG2
| (color_arg
[1] << MC_ARG2_SHIFT
)
480 alpha_combine
|= GFX_OP_MAP_ALPHA_STAGES
| (*alpha_stage
<< MA_STAGE_SHIFT
)
481 | MA_UPDATE_ARG1
| (alpha_arg
[0] << MA_ARG1_SHIFT
)
482 | MA_UPDATE_ARG2
| (alpha_arg
[1] << MA_ARG2_SHIFT
)
485 set_color_stage( color_combine
, *color_stage
, imesa
);
486 set_alpha_stage( alpha_combine
, *alpha_stage
, imesa
);
492 * Apply the scale factor.
494 /* The only operation where the i810 directly supports adding a post-
495 * scale factor is modulate. For all the other modes the post-scale is
496 * emulated by inserting and extra modulate stage. For the modulate
497 * case, the scaling is handled above when color_combine / alpha_combine
501 if ( RGBshift
!= 0 ) {
502 const unsigned color_scale
= GFX_OP_MAP_COLOR_STAGES
503 | (*color_stage
<< MC_STAGE_SHIFT
)
504 | MC_UPDATE_DEST
| MC_DEST_CURRENT
505 | MC_UPDATE_ARG1
| (MC_ARG_CURRENT_COLOR
<< MC_ARG1_SHIFT
)
506 | MC_UPDATE_ARG2
| (MC_ARG_ONE
<< MC_ARG2_SHIFT
)
507 | MC_UPDATE_OP
| (MC_OP_MODULATE
+ RGBshift
);
509 if ( *color_stage
>= 3 ) {
513 set_color_stage( color_scale
, *color_stage
, imesa
);
519 const unsigned alpha_scale
= GFX_OP_MAP_ALPHA_STAGES
520 | (*alpha_stage
<< MA_STAGE_SHIFT
)
521 | MA_UPDATE_ARG1
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG1_SHIFT
)
522 | MA_UPDATE_ARG2
| (MA_ARG_ONE
<< MA_ARG2_SHIFT
)
523 | MA_UPDATE_OP
| (MA_OP_MODULATE
+ Ashift
);
525 if ( *alpha_stage
>= 3 ) {
529 set_alpha_stage( alpha_scale
, *alpha_stage
, imesa
);
536 static GLboolean
enable_tex_common( GLcontext
*ctx
, GLuint unit
)
538 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
539 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
540 struct gl_texture_object
*tObj
= texUnit
->_Current
;
541 i810TextureObjectPtr t
= (i810TextureObjectPtr
)tObj
->DriverData
;
543 if (tObj
->Image
[0][tObj
->BaseLevel
]->Border
> 0) {
547 /* Upload teximages (not pipelined)
549 if (t
->base
.dirty_images
[0]) {
550 I810_FIREVERTICES(imesa
);
551 i810SetTexImages( imesa
, tObj
);
552 if (!t
->base
.memBlock
) {
557 /* Update state if this is a different texture object to last
560 if (imesa
->CurrentTexObj
[unit
] != t
) {
561 I810_STATECHANGE(imesa
, (I810_UPLOAD_TEX0
<<unit
));
562 imesa
->CurrentTexObj
[unit
] = t
;
563 t
->base
.bound
|= (1U << unit
);
565 /* XXX: should be locked */
566 driUpdateTextureLRU( (driTextureObject
*) t
);
569 imesa
->TexEnvImageFmt
[unit
] = tObj
->Image
[0][tObj
->BaseLevel
]->_BaseFormat
;
573 static GLboolean
enable_tex_rect( GLcontext
*ctx
, GLuint unit
)
575 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
576 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
577 struct gl_texture_object
*tObj
= texUnit
->_Current
;
578 i810TextureObjectPtr t
= (i810TextureObjectPtr
)tObj
->DriverData
;
581 Width
= tObj
->Image
[0][t
->base
.firstLevel
]->Width
- 1;
582 Height
= tObj
->Image
[0][t
->base
.firstLevel
]->Height
- 1;
584 I810_STATECHANGE(imesa
, (I810_UPLOAD_TEX0
<<unit
));
585 t
->Setup
[I810_TEXREG_MCS
] &= ~MCS_NORMALIZED_COORDS
;
586 t
->Setup
[I810_TEXREG_MCS
] |= MCS_UPDATE_NORMALIZED
;
587 t
->Setup
[I810_TEXREG_MI2
] = (MI2_DIMENSIONS_ARE_EXACT
|
588 (Height
<< MI2_HEIGHT_SHIFT
) | Width
);
593 static GLboolean
enable_tex_2d( GLcontext
*ctx
, GLuint unit
)
595 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
596 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
597 struct gl_texture_object
*tObj
= texUnit
->_Current
;
598 i810TextureObjectPtr t
= (i810TextureObjectPtr
)tObj
->DriverData
;
599 GLint log2Width
, log2Height
;
602 log2Width
= tObj
->Image
[0][t
->base
.firstLevel
]->WidthLog2
;
603 log2Height
= tObj
->Image
[0][t
->base
.firstLevel
]->HeightLog2
;
605 I810_STATECHANGE(imesa
, (I810_UPLOAD_TEX0
<<unit
));
606 t
->Setup
[I810_TEXREG_MCS
] |= MCS_NORMALIZED_COORDS
| MCS_UPDATE_NORMALIZED
;
607 t
->Setup
[I810_TEXREG_MI2
] = (MI2_DIMENSIONS_ARE_LOG2
|
608 (log2Height
<< MI2_HEIGHT_SHIFT
) | log2Width
);
613 static void disable_tex( GLcontext
*ctx
, GLuint unit
)
615 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
617 imesa
->CurrentTexObj
[unit
] = 0;
618 imesa
->TexEnvImageFmt
[unit
] = 0;
619 imesa
->dirty
&= ~(I810_UPLOAD_TEX0
<<unit
);
624 * Update hardware state for a texture unit.
627 * 1D textures should be supported! Just use a 2D texture with the second
628 * texture coordinate value fixed at 0.0.
630 static void i810UpdateTexUnit( GLcontext
*ctx
, GLuint unit
,
631 int * next_color_stage
, int * next_alpha_stage
)
633 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
634 struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[unit
];
637 switch(texUnit
->_ReallyEnabled
) {
639 ret
= enable_tex_common( ctx
, unit
);
640 ret
&= enable_tex_2d(ctx
, unit
);
641 if (ret
== GL_FALSE
) {
642 FALLBACK( imesa
, I810_FALLBACK_TEXTURE
, GL_TRUE
);
645 case TEXTURE_RECT_BIT
:
646 ret
= enable_tex_common( ctx
, unit
);
647 ret
&= enable_tex_rect(ctx
, unit
);
648 if (ret
== GL_FALSE
) {
649 FALLBACK( imesa
, I810_FALLBACK_TEXTURE
, GL_TRUE
);
653 disable_tex(ctx
, unit
);
658 if (!i810UpdateTexEnvCombine( ctx
, unit
,
659 next_color_stage
, next_alpha_stage
)) {
660 FALLBACK( imesa
, I810_FALLBACK_TEXTURE
, GL_TRUE
);
667 void i810UpdateTextureState( GLcontext
*ctx
)
669 static const unsigned color_pass
[3] = {
670 GFX_OP_MAP_COLOR_STAGES
| MC_STAGE_0
| MC_UPDATE_DEST
| MC_DEST_CURRENT
671 | MC_UPDATE_ARG1
| (MC_ARG_ITERATED_COLOR
<< MC_ARG1_SHIFT
)
672 | MC_UPDATE_ARG2
| (MC_ARG_ONE
<< MC_ARG2_SHIFT
)
673 | MC_UPDATE_OP
| MC_OP_ARG1
,
674 GFX_OP_MAP_COLOR_STAGES
| MC_STAGE_1
| MC_UPDATE_DEST
| MC_DEST_CURRENT
675 | MC_UPDATE_ARG1
| (MC_ARG_CURRENT_COLOR
<< MC_ARG1_SHIFT
)
676 | MC_UPDATE_ARG2
| (MC_ARG_ONE
<< MC_ARG2_SHIFT
)
677 | MC_UPDATE_OP
| MC_OP_ARG1
,
678 GFX_OP_MAP_COLOR_STAGES
| MC_STAGE_2
| MC_UPDATE_DEST
| MC_DEST_CURRENT
679 | MC_UPDATE_ARG1
| (MC_ARG_CURRENT_COLOR
<< MC_ARG1_SHIFT
)
680 | MC_UPDATE_ARG2
| (MC_ARG_ONE
<< MC_ARG2_SHIFT
)
681 | MC_UPDATE_OP
| MC_OP_ARG1
683 static const unsigned alpha_pass
[3] = {
684 GFX_OP_MAP_ALPHA_STAGES
| MA_STAGE_0
685 | MA_UPDATE_ARG1
| (MA_ARG_ITERATED_ALPHA
<< MA_ARG1_SHIFT
)
686 | MA_UPDATE_ARG2
| (MA_ARG_ITERATED_ALPHA
<< MA_ARG2_SHIFT
)
687 | MA_UPDATE_OP
| MA_OP_ARG1
,
688 GFX_OP_MAP_ALPHA_STAGES
| MA_STAGE_1
689 | MA_UPDATE_ARG1
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG1_SHIFT
)
690 | MA_UPDATE_ARG2
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG2_SHIFT
)
691 | MA_UPDATE_OP
| MA_OP_ARG1
,
692 GFX_OP_MAP_ALPHA_STAGES
| MA_STAGE_2
693 | MA_UPDATE_ARG1
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG1_SHIFT
)
694 | MA_UPDATE_ARG2
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG2_SHIFT
)
695 | MA_UPDATE_OP
| MA_OP_ARG1
697 i810ContextPtr imesa
= I810_CONTEXT(ctx
);
698 int next_color_stage
= 0;
699 int next_alpha_stage
= 0;
702 /* fprintf(stderr, "%s\n", __FUNCTION__); */
703 FALLBACK( imesa
, I810_FALLBACK_TEXTURE
, GL_FALSE
);
705 i810UpdateTexUnit( ctx
, 0, & next_color_stage
, & next_alpha_stage
);
706 i810UpdateTexUnit( ctx
, 1, & next_color_stage
, & next_alpha_stage
);
708 /* There needs to be at least one combine stage emitted that just moves
709 * the incoming primary color to the current color register. In addition,
710 * there number be the same number of color and alpha stages emitted.
711 * Finally, if there are less than 3 combine stages, a MC_OP_DISABLE stage
715 while ( (next_color_stage
== 0) ||
716 (next_color_stage
< next_alpha_stage
) ) {
717 set_color_stage( color_pass
[ next_color_stage
], next_color_stage
,
722 assert( next_color_stage
<= 3 );
724 while ( next_alpha_stage
< next_color_stage
) {
725 set_alpha_stage( alpha_pass
[ next_alpha_stage
], next_alpha_stage
,
730 assert( next_alpha_stage
<= 3 );
731 assert( next_color_stage
== next_alpha_stage
);
733 if ( next_color_stage
< 3 ) {
734 const unsigned color
= GFX_OP_MAP_COLOR_STAGES
735 | (next_color_stage
<< MC_STAGE_SHIFT
)
736 | MC_UPDATE_DEST
| MC_DEST_CURRENT
737 | MC_UPDATE_ARG1
| (MC_ARG_ONE
<< MC_ARG1_SHIFT
)
738 | MC_UPDATE_ARG2
| (MC_ARG_ONE
<< MC_ARG2_SHIFT
)
739 | MC_UPDATE_OP
| (MC_OP_DISABLE
);
741 const unsigned alpha
= GFX_OP_MAP_ALPHA_STAGES
742 | (next_color_stage
<< MC_STAGE_SHIFT
)
743 | MA_UPDATE_ARG1
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG1_SHIFT
)
744 | MA_UPDATE_ARG2
| (MA_ARG_CURRENT_ALPHA
<< MA_ARG2_SHIFT
)
745 | MA_UPDATE_OP
| (MA_OP_ARG1
);
747 set_color_stage( color
, next_color_stage
, imesa
);
748 set_alpha_stage( alpha
, next_alpha_stage
, imesa
);