1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
31 #include "shader/program.h"
32 #include "shader/prog_parameter.h"
33 #include "shader/prog_cache.h"
34 #include "shader/prog_instruction.h"
35 #include "shader/prog_print.h"
36 #include "shader/prog_statevars.h"
37 #include "shader/programopt.h"
38 #include "texenvprogram.h"
41 struct texenvprog_cache_item
45 struct gl_fragment_program
*data
;
46 struct texenvprog_cache_item
*next
;
51 * Up to nine instructions per tex unit, plus fog, specular color.
53 #define MAX_INSTRUCTIONS ((MAX_TEXTURE_UNITS * 9) + 12)
55 #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
63 GLuint nr_enabled_units
:8;
64 GLuint enabled_units
:8;
65 GLuint separate_specular
:1;
68 GLuint inputs_available
:12;
72 GLuint source_index
:3; /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */
74 GLuint ScaleShiftRGB
:2;
82 struct mode_opt OptRGB
[3];
83 struct mode_opt OptA
[3];
92 static GLuint
translate_fog_mode( GLenum mode
)
95 case GL_LINEAR
: return FOG_LINEAR
;
96 case GL_EXP
: return FOG_EXP
;
97 case GL_EXP2
: return FOG_EXP2
;
98 default: return FOG_UNKNOWN
;
102 #define OPR_SRC_COLOR 0
103 #define OPR_ONE_MINUS_SRC_COLOR 1
104 #define OPR_SRC_ALPHA 2
105 #define OPR_ONE_MINUS_SRC_ALPHA 3
108 #define OPR_UNKNOWN 7
110 static GLuint
translate_operand( GLenum operand
)
113 case GL_SRC_COLOR
: return OPR_SRC_COLOR
;
114 case GL_ONE_MINUS_SRC_COLOR
: return OPR_ONE_MINUS_SRC_COLOR
;
115 case GL_SRC_ALPHA
: return OPR_SRC_ALPHA
;
116 case GL_ONE_MINUS_SRC_ALPHA
: return OPR_ONE_MINUS_SRC_ALPHA
;
117 case GL_ZERO
: return OPR_ZERO
;
118 case GL_ONE
: return OPR_ONE
;
119 default: return OPR_UNKNOWN
;
123 #define SRC_TEXTURE 0
124 #define SRC_TEXTURE0 1
125 #define SRC_TEXTURE1 2
126 #define SRC_TEXTURE2 3
127 #define SRC_TEXTURE3 4
128 #define SRC_TEXTURE4 5
129 #define SRC_TEXTURE5 6
130 #define SRC_TEXTURE6 7
131 #define SRC_TEXTURE7 8
132 #define SRC_CONSTANT 9
133 #define SRC_PRIMARY_COLOR 10
134 #define SRC_PREVIOUS 11
135 #define SRC_UNKNOWN 15
137 static GLuint
translate_source( GLenum src
)
140 case GL_TEXTURE
: return SRC_TEXTURE
;
148 case GL_TEXTURE7
: return SRC_TEXTURE0
+ (src
- GL_TEXTURE0
);
149 case GL_CONSTANT
: return SRC_CONSTANT
;
150 case GL_PRIMARY_COLOR
: return SRC_PRIMARY_COLOR
;
151 case GL_PREVIOUS
: return SRC_PREVIOUS
;
152 default: return SRC_UNKNOWN
;
156 #define MODE_REPLACE 0
157 #define MODE_MODULATE 1
159 #define MODE_ADD_SIGNED 3
160 #define MODE_INTERPOLATE 4
161 #define MODE_SUBTRACT 5
162 #define MODE_DOT3_RGB 6
163 #define MODE_DOT3_RGB_EXT 7
164 #define MODE_DOT3_RGBA 8
165 #define MODE_DOT3_RGBA_EXT 9
166 #define MODE_MODULATE_ADD_ATI 10
167 #define MODE_MODULATE_SIGNED_ADD_ATI 11
168 #define MODE_MODULATE_SUBTRACT_ATI 12
169 #define MODE_UNKNOWN 15
171 static GLuint
translate_mode( GLenum mode
)
174 case GL_REPLACE
: return MODE_REPLACE
;
175 case GL_MODULATE
: return MODE_MODULATE
;
176 case GL_ADD
: return MODE_ADD
;
177 case GL_ADD_SIGNED
: return MODE_ADD_SIGNED
;
178 case GL_INTERPOLATE
: return MODE_INTERPOLATE
;
179 case GL_SUBTRACT
: return MODE_SUBTRACT
;
180 case GL_DOT3_RGB
: return MODE_DOT3_RGB
;
181 case GL_DOT3_RGB_EXT
: return MODE_DOT3_RGB_EXT
;
182 case GL_DOT3_RGBA
: return MODE_DOT3_RGBA
;
183 case GL_DOT3_RGBA_EXT
: return MODE_DOT3_RGBA_EXT
;
184 case GL_MODULATE_ADD_ATI
: return MODE_MODULATE_ADD_ATI
;
185 case GL_MODULATE_SIGNED_ADD_ATI
: return MODE_MODULATE_SIGNED_ADD_ATI
;
186 case GL_MODULATE_SUBTRACT_ATI
: return MODE_MODULATE_SUBTRACT_ATI
;
187 default: return MODE_UNKNOWN
;
191 #define TEXTURE_UNKNOWN_INDEX 7
192 static GLuint
translate_tex_src_bit( GLbitfield bit
)
194 /* make sure number of switch cases is correct */
195 assert(NUM_TEXTURE_TARGETS
== 7);
197 case TEXTURE_1D_BIT
: return TEXTURE_1D_INDEX
;
198 case TEXTURE_2D_BIT
: return TEXTURE_2D_INDEX
;
199 case TEXTURE_3D_BIT
: return TEXTURE_3D_INDEX
;
200 case TEXTURE_CUBE_BIT
: return TEXTURE_CUBE_INDEX
;
201 case TEXTURE_RECT_BIT
: return TEXTURE_RECT_INDEX
;
202 case TEXTURE_1D_ARRAY_BIT
: return TEXTURE_1D_ARRAY_INDEX
;
203 case TEXTURE_2D_ARRAY_BIT
: return TEXTURE_2D_ARRAY_INDEX
;
204 default: return TEXTURE_UNKNOWN_INDEX
;
208 #define VERT_BIT_TEX_ANY (0xff << VERT_ATTRIB_TEX0)
209 #define VERT_RESULT_TEX_ANY (0xff << VERT_RESULT_TEX0)
212 * Identify all possible varying inputs. The fragment program will
213 * never reference non-varying inputs, but will track them via state
216 * This function figures out all the inputs that the fragment program
217 * has access to. The bitmask is later reduced to just those which
218 * are actually referenced.
220 static GLbitfield
get_fp_input_mask( GLcontext
*ctx
)
222 GLbitfield fp_inputs
= 0x0;
224 if (ctx
->VertexProgram
._Overriden
) {
225 /* Somebody's messing with the vertex program and we don't have
226 * a clue what's happening. Assume that it could be producing
227 * all possible outputs.
231 else if (ctx
->RenderMode
== GL_FEEDBACK
) {
232 fp_inputs
= (FRAG_BIT_COL0
| FRAG_BIT_TEX0
);
234 else if (!ctx
->VertexProgram
._Enabled
||
235 !ctx
->VertexProgram
._Current
) {
237 /* Fixed function logic */
238 GLbitfield varying_inputs
= ctx
->varying_vp_inputs
;
240 /* These get generated in the setup routine regardless of the
243 if (ctx
->Point
.PointSprite
)
244 varying_inputs
|= FRAG_BITS_TEX_ANY
;
246 /* First look at what values may be computed by the generated
249 if (ctx
->Light
.Enabled
) {
250 fp_inputs
|= FRAG_BIT_COL0
;
252 if (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
)
253 fp_inputs
|= FRAG_BIT_COL1
;
256 fp_inputs
|= (ctx
->Texture
._TexGenEnabled
|
257 ctx
->Texture
._TexMatEnabled
) << FRAG_ATTRIB_TEX0
;
259 /* Then look at what might be varying as a result of enabled
262 if (varying_inputs
& VERT_BIT_COLOR0
) fp_inputs
|= FRAG_BIT_COL0
;
263 if (varying_inputs
& VERT_BIT_COLOR1
) fp_inputs
|= FRAG_BIT_COL1
;
265 fp_inputs
|= (((varying_inputs
& VERT_BIT_TEX_ANY
) >> VERT_ATTRIB_TEX0
)
266 << FRAG_ATTRIB_TEX0
);
270 /* calculate from vp->outputs */
271 GLbitfield vp_outputs
= ctx
->VertexProgram
._Current
->Base
.OutputsWritten
;
273 /* These get generated in the setup routine regardless of the
276 if (ctx
->Point
.PointSprite
)
277 vp_outputs
|= FRAG_BITS_TEX_ANY
;
279 if (vp_outputs
& (1 << VERT_RESULT_COL0
)) fp_inputs
|= FRAG_BIT_COL0
;
280 if (vp_outputs
& (1 << VERT_RESULT_COL1
)) fp_inputs
|= FRAG_BIT_COL1
;
282 fp_inputs
|= (((vp_outputs
& VERT_RESULT_TEX_ANY
) >> VERT_RESULT_TEX0
)
283 << FRAG_ATTRIB_TEX0
);
291 * Examine current texture environment state and generate a unique
292 * key to identify it.
294 static void make_state_key( GLcontext
*ctx
, struct state_key
*key
)
297 GLbitfield inputs_referenced
= FRAG_BIT_COL0
;
298 GLbitfield inputs_available
= get_fp_input_mask( ctx
);
300 memset(key
, 0, sizeof(*key
));
302 for (i
=0;i
<MAX_TEXTURE_UNITS
;i
++) {
303 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[i
];
306 if (!texUnit
->_ReallyEnabled
|| !texUnit
->Enabled
)
309 format
= texUnit
->_Current
->Image
[0][texUnit
->_Current
->BaseLevel
]->_BaseFormat
;
311 key
->unit
[i
].enabled
= 1;
312 key
->enabled_units
|= (1<<i
);
313 key
->nr_enabled_units
= i
+1;
314 inputs_referenced
|= FRAG_BIT_TEX(i
);
316 key
->unit
[i
].source_index
=
317 translate_tex_src_bit(texUnit
->_ReallyEnabled
);
318 key
->unit
[i
].shadow
= ((texUnit
->_Current
->CompareMode
== GL_COMPARE_R_TO_TEXTURE
) &&
319 ((format
== GL_DEPTH_COMPONENT
) ||
320 (format
== GL_DEPTH_STENCIL_EXT
)));
322 key
->unit
[i
].NumArgsRGB
= texUnit
->_CurrentCombine
->_NumArgsRGB
;
323 key
->unit
[i
].NumArgsA
= texUnit
->_CurrentCombine
->_NumArgsA
;
325 key
->unit
[i
].ModeRGB
=
326 translate_mode(texUnit
->_CurrentCombine
->ModeRGB
);
328 translate_mode(texUnit
->_CurrentCombine
->ModeA
);
330 key
->unit
[i
].ScaleShiftRGB
= texUnit
->_CurrentCombine
->ScaleShiftRGB
;
331 key
->unit
[i
].ScaleShiftA
= texUnit
->_CurrentCombine
->ScaleShiftA
;
334 key
->unit
[i
].OptRGB
[j
].Operand
=
335 translate_operand(texUnit
->_CurrentCombine
->OperandRGB
[j
]);
336 key
->unit
[i
].OptA
[j
].Operand
=
337 translate_operand(texUnit
->_CurrentCombine
->OperandA
[j
]);
338 key
->unit
[i
].OptRGB
[j
].Source
=
339 translate_source(texUnit
->_CurrentCombine
->SourceRGB
[j
]);
340 key
->unit
[i
].OptA
[j
].Source
=
341 translate_source(texUnit
->_CurrentCombine
->SourceA
[j
]);
345 if (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
) {
346 key
->separate_specular
= 1;
347 inputs_referenced
|= FRAG_BIT_COL1
;
350 if (ctx
->Fog
.Enabled
) {
351 key
->fog_enabled
= 1;
352 key
->fog_mode
= translate_fog_mode(ctx
->Fog
.Mode
);
353 inputs_referenced
|= FRAG_BIT_FOGC
; /* maybe */
356 key
->inputs_available
= (inputs_available
& inputs_referenced
);
360 * Use uregs to represent registers internally, translate to Mesa's
361 * expected formats on emit.
363 * NOTE: These are passed by value extensively in this file rather
364 * than as usual by pointer reference. If this disturbs you, try
365 * remembering they are just 32bits in size.
367 * GCC is smart enough to deal with these dword-sized structures in
368 * much the same way as if I had defined them as dwords and was using
369 * macros to access and set the fields. This is much nicer and easier
382 static const struct ureg undef
= {
393 /** State used to build the fragment program:
395 struct texenv_fragment_program
{
396 struct gl_fragment_program
*program
;
398 struct state_key
*state
;
400 GLbitfield alu_temps
; /**< Track texture indirections, see spec. */
401 GLbitfield temps_output
; /**< Track texture indirections, see spec. */
402 GLbitfield temp_in_use
; /**< Tracks temporary regs which are in use. */
405 struct ureg src_texture
[MAX_TEXTURE_UNITS
];
406 /* Reg containing each texture unit's sampled texture color,
410 struct ureg src_previous
; /**< Reg containing color from previous
411 * stage. May need to be decl'd.
414 GLuint last_tex_stage
; /**< Number of last enabled texture unit */
423 static struct ureg
make_ureg(GLuint file
, GLuint idx
)
431 reg
.swz
= SWIZZLE_NOOP
;
436 static struct ureg
swizzle( struct ureg reg
, int x
, int y
, int z
, int w
)
438 reg
.swz
= MAKE_SWIZZLE4(GET_SWZ(reg
.swz
, x
),
441 GET_SWZ(reg
.swz
, w
));
446 static struct ureg
swizzle1( struct ureg reg
, int x
)
448 return swizzle(reg
, x
, x
, x
, x
);
451 static struct ureg
negate( struct ureg reg
)
457 static GLboolean
is_undef( struct ureg reg
)
459 return reg
.file
== PROGRAM_UNDEFINED
;
463 static struct ureg
get_temp( struct texenv_fragment_program
*p
)
467 /* First try and reuse temps which have been used already:
469 bit
= _mesa_ffs( ~p
->temp_in_use
& p
->alu_temps
);
471 /* Then any unused temporary:
474 bit
= _mesa_ffs( ~p
->temp_in_use
);
477 _mesa_problem(NULL
, "%s: out of temporaries\n", __FILE__
);
481 if ((GLuint
) bit
> p
->program
->Base
.NumTemporaries
)
482 p
->program
->Base
.NumTemporaries
= bit
;
484 p
->temp_in_use
|= 1<<(bit
-1);
485 return make_ureg(PROGRAM_TEMPORARY
, (bit
-1));
488 static struct ureg
get_tex_temp( struct texenv_fragment_program
*p
)
492 /* First try to find available temp not previously used (to avoid
493 * starting a new texture indirection). According to the spec, the
494 * ~p->temps_output isn't necessary, but will keep it there for
497 bit
= _mesa_ffs( ~p
->temp_in_use
& ~p
->alu_temps
& ~p
->temps_output
);
499 /* Then any unused temporary:
502 bit
= _mesa_ffs( ~p
->temp_in_use
);
505 _mesa_problem(NULL
, "%s: out of temporaries\n", __FILE__
);
509 if ((GLuint
) bit
> p
->program
->Base
.NumTemporaries
)
510 p
->program
->Base
.NumTemporaries
= bit
;
512 p
->temp_in_use
|= 1<<(bit
-1);
513 return make_ureg(PROGRAM_TEMPORARY
, (bit
-1));
517 /** Mark a temp reg as being no longer allocatable. */
518 static void reserve_temp( struct texenv_fragment_program
*p
, struct ureg r
)
520 if (r
.file
== PROGRAM_TEMPORARY
)
521 p
->temps_output
|= (1 << r
.idx
);
525 static void release_temps(GLcontext
*ctx
, struct texenv_fragment_program
*p
)
527 GLuint max_temp
= ctx
->Const
.FragmentProgram
.MaxTemps
;
529 /* KW: To support tex_env_crossbar, don't release the registers in
532 if (max_temp
>= sizeof(int) * 8)
533 p
->temp_in_use
= p
->temps_output
;
535 p
->temp_in_use
= ~((1<<max_temp
)-1) | p
->temps_output
;
539 static struct ureg
register_param5( struct texenv_fragment_program
*p
,
546 gl_state_index tokens
[STATE_LENGTH
];
553 idx
= _mesa_add_state_reference( p
->program
->Base
.Parameters
, tokens
);
554 return make_ureg(PROGRAM_STATE_VAR
, idx
);
558 #define register_param1(p,s0) register_param5(p,s0,0,0,0,0)
559 #define register_param2(p,s0,s1) register_param5(p,s0,s1,0,0,0)
560 #define register_param3(p,s0,s1,s2) register_param5(p,s0,s1,s2,0,0)
561 #define register_param4(p,s0,s1,s2,s3) register_param5(p,s0,s1,s2,s3,0)
563 static GLuint
frag_to_vert_attrib( GLuint attrib
)
566 case FRAG_ATTRIB_COL0
: return VERT_ATTRIB_COLOR0
;
567 case FRAG_ATTRIB_COL1
: return VERT_ATTRIB_COLOR1
;
569 assert(attrib
>= FRAG_ATTRIB_TEX0
);
570 assert(attrib
<= FRAG_ATTRIB_TEX7
);
571 return attrib
- FRAG_ATTRIB_TEX0
+ VERT_ATTRIB_TEX0
;
576 static struct ureg
register_input( struct texenv_fragment_program
*p
, GLuint input
)
578 if (p
->state
->inputs_available
& (1<<input
)) {
579 p
->program
->Base
.InputsRead
|= (1 << input
);
580 return make_ureg(PROGRAM_INPUT
, input
);
583 GLuint idx
= frag_to_vert_attrib( input
);
584 return register_param3( p
, STATE_INTERNAL
, STATE_CURRENT_ATTRIB
, idx
);
589 static void emit_arg( struct prog_src_register
*reg
,
592 reg
->File
= ureg
.file
;
593 reg
->Index
= ureg
.idx
;
594 reg
->Swizzle
= ureg
.swz
;
595 reg
->NegateBase
= ureg
.negatebase
? 0xf : 0x0;
597 reg
->NegateAbs
= ureg
.negateabs
;
600 static void emit_dst( struct prog_dst_register
*dst
,
601 struct ureg ureg
, GLuint mask
)
603 dst
->File
= ureg
.file
;
604 dst
->Index
= ureg
.idx
;
605 dst
->WriteMask
= mask
;
606 dst
->CondMask
= COND_TR
; /* always pass cond test */
607 dst
->CondSwizzle
= SWIZZLE_NOOP
;
610 static struct prog_instruction
*
611 emit_op(struct texenv_fragment_program
*p
,
620 GLuint nr
= p
->program
->Base
.NumInstructions
++;
621 struct prog_instruction
*inst
= &p
->program
->Base
.Instructions
[nr
];
623 assert(nr
< MAX_INSTRUCTIONS
);
625 _mesa_init_instructions(inst
, 1);
628 emit_arg( &inst
->SrcReg
[0], src0
);
629 emit_arg( &inst
->SrcReg
[1], src1
);
630 emit_arg( &inst
->SrcReg
[2], src2
);
632 inst
->SaturateMode
= saturate
? SATURATE_ZERO_ONE
: SATURATE_OFF
;
634 emit_dst( &inst
->DstReg
, dest
, mask
);
637 /* Accounting for indirection tracking:
639 if (dest
.file
== PROGRAM_TEMPORARY
)
640 p
->temps_output
|= 1 << dest
.idx
;
647 static struct ureg
emit_arith( struct texenv_fragment_program
*p
,
656 emit_op(p
, op
, dest
, mask
, saturate
, src0
, src1
, src2
);
658 /* Accounting for indirection tracking:
660 if (src0
.file
== PROGRAM_TEMPORARY
)
661 p
->alu_temps
|= 1 << src0
.idx
;
663 if (!is_undef(src1
) && src1
.file
== PROGRAM_TEMPORARY
)
664 p
->alu_temps
|= 1 << src1
.idx
;
666 if (!is_undef(src2
) && src2
.file
== PROGRAM_TEMPORARY
)
667 p
->alu_temps
|= 1 << src2
.idx
;
669 if (dest
.file
== PROGRAM_TEMPORARY
)
670 p
->alu_temps
|= 1 << dest
.idx
;
672 p
->program
->Base
.NumAluInstructions
++;
676 static struct ureg
emit_texld( struct texenv_fragment_program
*p
,
684 struct prog_instruction
*inst
= emit_op( p
, op
,
686 GL_FALSE
, /* don't saturate? */
691 inst
->TexSrcTarget
= tex_idx
;
692 inst
->TexSrcUnit
= tex_unit
;
694 p
->program
->Base
.NumTexInstructions
++;
696 /* Accounting for indirection tracking:
698 reserve_temp(p
, dest
);
700 /* Is this a texture indirection?
702 if ((coord
.file
== PROGRAM_TEMPORARY
&&
703 (p
->temps_output
& (1<<coord
.idx
))) ||
704 (dest
.file
== PROGRAM_TEMPORARY
&&
705 (p
->alu_temps
& (1<<dest
.idx
)))) {
706 p
->program
->Base
.NumTexIndirections
++;
707 p
->temps_output
= 1<<coord
.idx
;
709 assert(0); /* KW: texture env crossbar */
716 static struct ureg
register_const4f( struct texenv_fragment_program
*p
,
729 idx
= _mesa_add_unnamed_constant( p
->program
->Base
.Parameters
, values
, 4,
731 r
= make_ureg(PROGRAM_CONSTANT
, idx
);
736 #define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
737 #define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
738 #define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
739 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
742 static struct ureg
get_one( struct texenv_fragment_program
*p
)
744 if (is_undef(p
->one
))
745 p
->one
= register_scalar_const(p
, 1.0);
749 static struct ureg
get_half( struct texenv_fragment_program
*p
)
751 if (is_undef(p
->half
))
752 p
->half
= register_scalar_const(p
, 0.5);
756 static struct ureg
get_zero( struct texenv_fragment_program
*p
)
758 if (is_undef(p
->zero
))
759 p
->zero
= register_scalar_const(p
, 0.0);
764 static void program_error( struct texenv_fragment_program
*p
, const char *msg
)
766 _mesa_problem(NULL
, msg
);
770 static struct ureg
get_source( struct texenv_fragment_program
*p
,
771 GLuint src
, GLuint unit
)
775 assert(!is_undef(p
->src_texture
[unit
]));
776 return p
->src_texture
[unit
];
786 assert(!is_undef(p
->src_texture
[src
- SRC_TEXTURE0
]));
787 return p
->src_texture
[src
- SRC_TEXTURE0
];
790 return register_param2(p
, STATE_TEXENV_COLOR
, unit
);
792 case SRC_PRIMARY_COLOR
:
793 return register_input(p
, FRAG_ATTRIB_COL0
);
797 if (is_undef(p
->src_previous
))
798 return register_input(p
, FRAG_ATTRIB_COL0
);
800 return p
->src_previous
;
804 static struct ureg
emit_combine_source( struct texenv_fragment_program
*p
,
810 struct ureg arg
, src
, one
;
812 src
= get_source(p
, source
, unit
);
815 case OPR_ONE_MINUS_SRC_COLOR
:
817 * Emit tmp = 1.0 - arg.xyzw
821 return emit_arith( p
, OPCODE_SUB
, arg
, mask
, 0, one
, src
, undef
);
824 if (mask
== WRITEMASK_W
)
827 return swizzle1( src
, SWIZZLE_W
);
828 case OPR_ONE_MINUS_SRC_ALPHA
:
830 * Emit tmp = 1.0 - arg.wwww
834 return emit_arith(p
, OPCODE_SUB
, arg
, mask
, 0,
835 one
, swizzle1(src
, SWIZZLE_W
), undef
);
846 static GLboolean
args_match( struct state_key
*key
, GLuint unit
)
848 GLuint i
, nr
= key
->unit
[unit
].NumArgsRGB
;
850 for (i
= 0 ; i
< nr
; i
++) {
851 if (key
->unit
[unit
].OptA
[i
].Source
!= key
->unit
[unit
].OptRGB
[i
].Source
)
854 switch(key
->unit
[unit
].OptA
[i
].Operand
) {
856 switch(key
->unit
[unit
].OptRGB
[i
].Operand
) {
864 case OPR_ONE_MINUS_SRC_ALPHA
:
865 switch(key
->unit
[unit
].OptRGB
[i
].Operand
) {
866 case OPR_ONE_MINUS_SRC_COLOR
:
867 case OPR_ONE_MINUS_SRC_ALPHA
:
874 return GL_FALSE
; /* impossible */
881 static struct ureg
emit_combine( struct texenv_fragment_program
*p
,
888 const struct mode_opt
*opt
)
891 struct ureg tmp
, half
;
894 tmp
= undef
; /* silence warning (bug 5318) */
896 for (i
= 0; i
< nr
; i
++)
897 src
[i
] = emit_combine_source( p
, mask
, unit
, opt
[i
].Source
, opt
[i
].Operand
);
901 if (mask
== WRITEMASK_XYZW
&& !saturate
)
904 return emit_arith( p
, OPCODE_MOV
, dest
, mask
, saturate
, src
[0], undef
, undef
);
906 return emit_arith( p
, OPCODE_MUL
, dest
, mask
, saturate
,
907 src
[0], src
[1], undef
);
909 return emit_arith( p
, OPCODE_ADD
, dest
, mask
, saturate
,
910 src
[0], src
[1], undef
);
911 case MODE_ADD_SIGNED
:
917 emit_arith( p
, OPCODE_ADD
, tmp
, mask
, 0, src
[0], src
[1], undef
);
918 emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, tmp
, half
, undef
);
920 case MODE_INTERPOLATE
:
921 /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
923 return emit_arith( p
, OPCODE_LRP
, dest
, mask
, saturate
, src
[2], src
[0], src
[1] );
926 return emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, src
[0], src
[1], undef
);
929 case MODE_DOT3_RGBA_EXT
:
930 case MODE_DOT3_RGB_EXT
:
931 case MODE_DOT3_RGB
: {
932 struct ureg tmp0
= get_temp( p
);
933 struct ureg tmp1
= get_temp( p
);
934 struct ureg neg1
= register_scalar_const(p
, -1);
935 struct ureg two
= register_scalar_const(p
, 2);
940 * dst = tmp0 dot3 tmp1
942 emit_arith( p
, OPCODE_MAD
, tmp0
, WRITEMASK_XYZW
, 0,
945 if (_mesa_memcmp(&src
[0], &src
[1], sizeof(struct ureg
)) == 0)
948 emit_arith( p
, OPCODE_MAD
, tmp1
, WRITEMASK_XYZW
, 0,
950 emit_arith( p
, OPCODE_DP3
, dest
, mask
, saturate
, tmp0
, tmp1
, undef
);
953 case MODE_MODULATE_ADD_ATI
:
954 /* Arg0 * Arg2 + Arg1 */
955 return emit_arith( p
, OPCODE_MAD
, dest
, mask
, saturate
,
956 src
[0], src
[2], src
[1] );
957 case MODE_MODULATE_SIGNED_ADD_ATI
: {
958 /* Arg0 * Arg2 + Arg1 - 0.5 */
959 struct ureg tmp0
= get_temp(p
);
961 emit_arith( p
, OPCODE_MAD
, tmp0
, mask
, 0, src
[0], src
[2], src
[1] );
962 emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, tmp0
, half
, undef
);
965 case MODE_MODULATE_SUBTRACT_ATI
:
966 /* Arg0 * Arg2 - Arg1 */
967 emit_arith( p
, OPCODE_MAD
, dest
, mask
, 0, src
[0], src
[2], negate(src
[1]) );
976 * Generate instructions for one texture unit's env/combiner mode.
979 emit_texenv(struct texenv_fragment_program
*p
, GLuint unit
)
981 struct state_key
*key
= p
->state
;
982 GLboolean saturate
= (unit
< p
->last_tex_stage
);
983 GLuint rgb_shift
, alpha_shift
;
984 struct ureg out
, shift
;
987 if (!key
->unit
[unit
].enabled
) {
988 return get_source(p
, SRC_PREVIOUS
, 0);
991 switch (key
->unit
[unit
].ModeRGB
) {
992 case MODE_DOT3_RGB_EXT
:
993 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
996 case MODE_DOT3_RGBA_EXT
:
1001 rgb_shift
= key
->unit
[unit
].ScaleShiftRGB
;
1002 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
1006 /* If this is the very last calculation, emit direct to output reg:
1008 if (key
->separate_specular
||
1009 unit
!= p
->last_tex_stage
||
1012 dest
= get_temp( p
);
1014 dest
= make_ureg(PROGRAM_OUTPUT
, FRAG_RESULT_COLR
);
1016 /* Emit the RGB and A combine ops
1018 if (key
->unit
[unit
].ModeRGB
== key
->unit
[unit
].ModeA
&&
1019 args_match(key
, unit
)) {
1020 out
= emit_combine( p
, dest
, WRITEMASK_XYZW
, saturate
,
1022 key
->unit
[unit
].NumArgsRGB
,
1023 key
->unit
[unit
].ModeRGB
,
1024 key
->unit
[unit
].OptRGB
);
1026 else if (key
->unit
[unit
].ModeRGB
== MODE_DOT3_RGBA_EXT
||
1027 key
->unit
[unit
].ModeRGB
== MODE_DOT3_RGBA
) {
1029 out
= emit_combine( p
, dest
, WRITEMASK_XYZW
, saturate
,
1031 key
->unit
[unit
].NumArgsRGB
,
1032 key
->unit
[unit
].ModeRGB
,
1033 key
->unit
[unit
].OptRGB
);
1036 /* Need to do something to stop from re-emitting identical
1037 * argument calculations here:
1039 out
= emit_combine( p
, dest
, WRITEMASK_XYZ
, saturate
,
1041 key
->unit
[unit
].NumArgsRGB
,
1042 key
->unit
[unit
].ModeRGB
,
1043 key
->unit
[unit
].OptRGB
);
1044 out
= emit_combine( p
, dest
, WRITEMASK_W
, saturate
,
1046 key
->unit
[unit
].NumArgsA
,
1047 key
->unit
[unit
].ModeA
,
1048 key
->unit
[unit
].OptA
);
1051 /* Deal with the final shift:
1053 if (alpha_shift
|| rgb_shift
) {
1054 if (rgb_shift
== alpha_shift
) {
1055 shift
= register_scalar_const(p
, (GLfloat
)(1<<rgb_shift
));
1058 shift
= register_const4f(p
,
1059 (GLfloat
)(1<<rgb_shift
),
1060 (GLfloat
)(1<<rgb_shift
),
1061 (GLfloat
)(1<<rgb_shift
),
1062 (GLfloat
)(1<<alpha_shift
));
1064 return emit_arith( p
, OPCODE_MUL
, dest
, WRITEMASK_XYZW
,
1065 saturate
, out
, shift
, undef
);
1073 * Generate instruction for getting a texture source term.
1075 static void load_texture( struct texenv_fragment_program
*p
, GLuint unit
)
1077 if (is_undef(p
->src_texture
[unit
])) {
1078 GLuint dim
= p
->state
->unit
[unit
].source_index
;
1079 struct ureg texcoord
= register_input(p
, FRAG_ATTRIB_TEX0
+unit
);
1080 struct ureg tmp
= get_tex_temp( p
);
1082 if (dim
== TEXTURE_UNKNOWN_INDEX
)
1083 program_error(p
, "TexSrcBit");
1085 /* TODO: Use D0_MASK_XY where possible.
1087 if (p
->state
->unit
[unit
].enabled
) {
1088 p
->src_texture
[unit
] = emit_texld( p
, OPCODE_TXP
,
1089 tmp
, WRITEMASK_XYZW
,
1090 unit
, dim
, texcoord
);
1092 if (p
->state
->unit
[unit
].shadow
)
1093 p
->program
->Base
.ShadowSamplers
|= 1 << unit
;
1095 p
->program
->Base
.SamplersUsed
|= (1 << unit
);
1096 /* This identity mapping should already be in place
1097 * (see _mesa_init_program_struct()) but let's be safe.
1099 p
->program
->Base
.SamplerUnits
[unit
] = unit
;
1102 p
->src_texture
[unit
] = get_zero(p
);
1106 static GLboolean
load_texenv_source( struct texenv_fragment_program
*p
,
1107 GLuint src
, GLuint unit
)
1111 load_texture(p
, unit
);
1122 load_texture(p
, src
- SRC_TEXTURE0
);
1134 * Generate instructions for loading all texture source terms.
1137 load_texunit_sources( struct texenv_fragment_program
*p
, int unit
)
1139 struct state_key
*key
= p
->state
;
1142 for (i
= 0; i
< key
->unit
[unit
].NumArgsRGB
; i
++) {
1143 load_texenv_source( p
, key
->unit
[unit
].OptRGB
[i
].Source
, unit
);
1146 for (i
= 0; i
< key
->unit
[unit
].NumArgsA
; i
++) {
1147 load_texenv_source( p
, key
->unit
[unit
].OptA
[i
].Source
, unit
);
1155 * Generate a new fragment program which implements the context's
1156 * current texture env/combine mode.
1159 create_new_program(GLcontext
*ctx
, struct state_key
*key
,
1160 struct gl_fragment_program
*program
)
1162 struct prog_instruction instBuffer
[MAX_INSTRUCTIONS
];
1163 struct texenv_fragment_program p
;
1165 struct ureg cf
, out
;
1167 _mesa_memset(&p
, 0, sizeof(p
));
1170 p
.program
= program
;
1172 /* During code generation, use locally-allocated instruction buffer,
1173 * then alloc dynamic storage below.
1175 p
.program
->Base
.Instructions
= instBuffer
;
1176 p
.program
->Base
.Target
= GL_FRAGMENT_PROGRAM_ARB
;
1177 p
.program
->Base
.NumTexIndirections
= 1; /* correct? */
1178 p
.program
->Base
.NumTexInstructions
= 0;
1179 p
.program
->Base
.NumAluInstructions
= 0;
1180 p
.program
->Base
.String
= NULL
;
1181 p
.program
->Base
.NumInstructions
=
1182 p
.program
->Base
.NumTemporaries
=
1183 p
.program
->Base
.NumParameters
=
1184 p
.program
->Base
.NumAttributes
= p
.program
->Base
.NumAddressRegs
= 0;
1185 p
.program
->Base
.Parameters
= _mesa_new_parameter_list();
1187 p
.program
->Base
.InputsRead
= 0;
1188 p
.program
->Base
.OutputsWritten
= 1 << FRAG_RESULT_COLR
;
1190 for (unit
= 0; unit
< MAX_TEXTURE_UNITS
; unit
++)
1191 p
.src_texture
[unit
] = undef
;
1193 p
.src_previous
= undef
;
1198 p
.last_tex_stage
= 0;
1199 release_temps(ctx
, &p
);
1201 if (key
->enabled_units
) {
1202 /* First pass - to support texture_env_crossbar, first identify
1203 * all referenced texture sources and emit texld instructions
1206 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++)
1207 if (key
->unit
[unit
].enabled
) {
1208 load_texunit_sources( &p
, unit
);
1209 p
.last_tex_stage
= unit
;
1212 /* Second pass - emit combine instructions to build final color:
1214 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++)
1215 if (key
->enabled_units
& (1<<unit
)) {
1216 p
.src_previous
= emit_texenv( &p
, unit
);
1217 reserve_temp(&p
, p
.src_previous
); /* don't re-use this temp reg */
1218 release_temps(ctx
, &p
); /* release all temps */
1222 cf
= get_source( &p
, SRC_PREVIOUS
, 0 );
1223 out
= make_ureg( PROGRAM_OUTPUT
, FRAG_RESULT_COLR
);
1225 if (key
->separate_specular
) {
1226 /* Emit specular add.
1228 struct ureg s
= register_input(&p
, FRAG_ATTRIB_COL1
);
1229 emit_arith( &p
, OPCODE_ADD
, out
, WRITEMASK_XYZ
, 0, cf
, s
, undef
);
1230 emit_arith( &p
, OPCODE_MOV
, out
, WRITEMASK_W
, 0, cf
, undef
, undef
);
1232 else if (_mesa_memcmp(&cf
, &out
, sizeof(cf
)) != 0) {
1233 /* Will wind up in here if no texture enabled or a couple of
1234 * other scenarios (GL_REPLACE for instance).
1236 emit_arith( &p
, OPCODE_MOV
, out
, WRITEMASK_XYZW
, 0, cf
, undef
, undef
);
1241 emit_arith( &p
, OPCODE_END
, undef
, WRITEMASK_XYZW
, 0, undef
, undef
, undef
);
1243 if (key
->fog_enabled
) {
1244 /* Pull fog mode from GLcontext, the value in the state key is
1245 * a reduced value and not what is expected in FogOption
1247 p
.program
->FogOption
= ctx
->Fog
.Mode
;
1248 p
.program
->Base
.InputsRead
|= FRAG_BIT_FOGC
; /* XXX new */
1250 p
.program
->FogOption
= GL_NONE
;
1252 if (p
.program
->Base
.NumTexIndirections
> ctx
->Const
.FragmentProgram
.MaxTexIndirections
)
1253 program_error(&p
, "Exceeded max nr indirect texture lookups");
1255 if (p
.program
->Base
.NumTexInstructions
> ctx
->Const
.FragmentProgram
.MaxTexInstructions
)
1256 program_error(&p
, "Exceeded max TEX instructions");
1258 if (p
.program
->Base
.NumAluInstructions
> ctx
->Const
.FragmentProgram
.MaxAluInstructions
)
1259 program_error(&p
, "Exceeded max ALU instructions");
1261 ASSERT(p
.program
->Base
.NumInstructions
<= MAX_INSTRUCTIONS
);
1263 /* Allocate final instruction array */
1264 p
.program
->Base
.Instructions
1265 = _mesa_alloc_instructions(p
.program
->Base
.NumInstructions
);
1266 if (!p
.program
->Base
.Instructions
) {
1267 _mesa_error(ctx
, GL_OUT_OF_MEMORY
,
1268 "generating tex env program");
1271 _mesa_copy_instructions(p
.program
->Base
.Instructions
, instBuffer
,
1272 p
.program
->Base
.NumInstructions
);
1274 if (p
.program
->FogOption
) {
1275 _mesa_append_fog_code(ctx
, p
.program
);
1276 p
.program
->FogOption
= GL_NONE
;
1280 /* Notify driver the fragment program has (actually) changed.
1282 if (ctx
->Driver
.ProgramStringNotify
) {
1283 ctx
->Driver
.ProgramStringNotify( ctx
, GL_FRAGMENT_PROGRAM_ARB
,
1288 _mesa_print_program(&p
.program
->Base
);
1295 * Return a fragment program which implements the current
1296 * fixed-function texture, fog and color-sum operations.
1298 struct gl_fragment_program
*
1299 _mesa_get_fixed_func_fragment_program(GLcontext
*ctx
)
1301 struct gl_fragment_program
*prog
;
1302 struct state_key key
;
1304 make_state_key(ctx
, &key
);
1306 prog
= (struct gl_fragment_program
*)
1307 _mesa_search_program_cache(ctx
->FragmentProgram
.Cache
,
1311 prog
= (struct gl_fragment_program
*)
1312 ctx
->Driver
.NewProgram(ctx
, GL_FRAGMENT_PROGRAM_ARB
, 0);
1314 create_new_program(ctx
, &key
, prog
);
1316 _mesa_program_cache_insert(ctx
, ctx
->FragmentProgram
.Cache
,
1317 &key
, sizeof(key
), &prog
->Base
);
1326 * If _MaintainTexEnvProgram is set we'll generate a fragment program that
1327 * implements the current texture env/combine mode.
1328 * This function generates that program and puts it into effect.
1330 * XXX: remove this function. currently only called by some drivers,
1331 * not by mesa core. We now handle this properly from inside mesa.
1334 _mesa_UpdateTexEnvProgram( GLcontext
*ctx
)
1336 const struct gl_fragment_program
*prev
= ctx
->FragmentProgram
._Current
;
1338 ASSERT(ctx
->FragmentProgram
._MaintainTexEnvProgram
);
1340 /* If a conventional fragment program/shader isn't in effect... */
1341 if (!ctx
->FragmentProgram
._Enabled
&&
1342 (!ctx
->Shader
.CurrentProgram
||
1343 !ctx
->Shader
.CurrentProgram
->FragmentProgram
) )
1345 struct gl_fragment_program
*newProg
;
1347 newProg
= _mesa_get_fixed_func_fragment_program(ctx
);
1349 _mesa_reference_fragprog(ctx
, &ctx
->FragmentProgram
._Current
, newProg
);
1350 _mesa_reference_fragprog(ctx
, &ctx
->FragmentProgram
._TexEnvProgram
, newProg
);
1353 /* Tell the driver about the change. Could define a new target for
1356 if (ctx
->FragmentProgram
._Current
!= prev
&& ctx
->Driver
.BindProgram
) {
1357 ctx
->Driver
.BindProgram(ctx
, GL_FRAGMENT_PROGRAM_ARB
,
1358 (struct gl_program
*) ctx
->FragmentProgram
._Current
);