1 /**************************************************************************
3 * Copyright 2003 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 "texenvprogram.h"
33 #include "shader/program.h"
34 #include "shader/program_instruction.h"
36 #define MAX_INSTRUCTIONS 100
38 #define DISASSEM (MESA_VERBOSE & VERBOSE_DISASSEM)
46 GLbitfield enabled_units
;
47 GLuint separate_specular
:1;
53 GLuint source_index
:3; /* one of TEXTURE_1D/2D/3D/CUBE/RECT_INDEX */
54 GLuint ScaleShiftRGB
:2;
59 struct mode_opt OptRGB
[3];
63 struct mode_opt OptA
[3];
72 static GLuint
translate_fog_mode( GLenum mode
)
75 case GL_LINEAR
: return FOG_LINEAR
;
76 case GL_EXP
: return FOG_EXP
;
77 case GL_EXP2
: return FOG_EXP2
;
78 default: return FOG_UNKNOWN
;
82 #define OPR_SRC_COLOR 0
83 #define OPR_ONE_MINUS_SRC_COLOR 1
84 #define OPR_SRC_ALPHA 2
85 #define OPR_ONE_MINUS_SRC_ALPHA 3
90 static GLuint
translate_operand( GLenum operand
)
93 case GL_SRC_COLOR
: return OPR_SRC_COLOR
;
94 case GL_ONE_MINUS_SRC_COLOR
: return OPR_ONE_MINUS_SRC_COLOR
;
95 case GL_SRC_ALPHA
: return OPR_SRC_ALPHA
;
96 case GL_ONE_MINUS_SRC_ALPHA
: return OPR_ONE_MINUS_SRC_ALPHA
;
97 case GL_ZERO
: return OPR_ZERO
;
98 case GL_ONE
: return OPR_ONE
;
99 default: return OPR_UNKNOWN
;
103 #define SRC_TEXTURE 0
104 #define SRC_TEXTURE0 1
105 #define SRC_TEXTURE1 2
106 #define SRC_TEXTURE2 3
107 #define SRC_TEXTURE3 4
108 #define SRC_TEXTURE4 5
109 #define SRC_TEXTURE5 6
110 #define SRC_TEXTURE6 7
111 #define SRC_TEXTURE7 8
112 #define SRC_CONSTANT 9
113 #define SRC_PRIMARY_COLOR 10
114 #define SRC_PREVIOUS 11
115 #define SRC_UNKNOWN 15
117 static GLuint
translate_source( GLenum src
)
120 case GL_TEXTURE
: return SRC_TEXTURE
;
128 case GL_TEXTURE7
: return SRC_TEXTURE0
+ (src
- GL_TEXTURE0
);
129 case GL_CONSTANT
: return SRC_CONSTANT
;
130 case GL_PRIMARY_COLOR
: return SRC_PRIMARY_COLOR
;
131 case GL_PREVIOUS
: return SRC_PREVIOUS
;
132 default: return SRC_UNKNOWN
;
136 #define MODE_REPLACE 0
137 #define MODE_MODULATE 1
139 #define MODE_ADD_SIGNED 3
140 #define MODE_INTERPOLATE 4
141 #define MODE_SUBTRACT 5
142 #define MODE_DOT3_RGB 6
143 #define MODE_DOT3_RGB_EXT 7
144 #define MODE_DOT3_RGBA 8
145 #define MODE_DOT3_RGBA_EXT 9
146 #define MODE_MODULATE_ADD_ATI 10
147 #define MODE_MODULATE_SIGNED_ADD_ATI 11
148 #define MODE_MODULATE_SUBTRACT_ATI 12
149 #define MODE_UNKNOWN 15
151 static GLuint
translate_mode( GLenum mode
)
154 case GL_REPLACE
: return MODE_REPLACE
;
155 case GL_MODULATE
: return MODE_MODULATE
;
156 case GL_ADD
: return MODE_ADD
;
157 case GL_ADD_SIGNED
: return MODE_ADD_SIGNED
;
158 case GL_INTERPOLATE
: return MODE_INTERPOLATE
;
159 case GL_SUBTRACT
: return MODE_SUBTRACT
;
160 case GL_DOT3_RGB
: return MODE_DOT3_RGB
;
161 case GL_DOT3_RGB_EXT
: return MODE_DOT3_RGB_EXT
;
162 case GL_DOT3_RGBA
: return MODE_DOT3_RGBA
;
163 case GL_DOT3_RGBA_EXT
: return MODE_DOT3_RGBA_EXT
;
164 case GL_MODULATE_ADD_ATI
: return MODE_MODULATE_ADD_ATI
;
165 case GL_MODULATE_SIGNED_ADD_ATI
: return MODE_MODULATE_SIGNED_ADD_ATI
;
166 case GL_MODULATE_SUBTRACT_ATI
: return MODE_MODULATE_SUBTRACT_ATI
;
167 default: return MODE_UNKNOWN
;
171 #define TEXTURE_UNKNOWN_INDEX 7
172 static GLuint
translate_tex_src_bit( GLbitfield bit
)
175 case TEXTURE_1D_BIT
: return TEXTURE_1D_INDEX
;
176 case TEXTURE_2D_BIT
: return TEXTURE_2D_INDEX
;
177 case TEXTURE_RECT_BIT
: return TEXTURE_RECT_INDEX
;
178 case TEXTURE_3D_BIT
: return TEXTURE_3D_INDEX
;
179 case TEXTURE_CUBE_BIT
: return TEXTURE_CUBE_INDEX
;
180 default: return TEXTURE_UNKNOWN_INDEX
;
185 * Examine current texture environment state and generate a unique
186 * key to identify it.
188 static void make_state_key( GLcontext
*ctx
, struct state_key
*key
)
192 memset(key
, 0, sizeof(*key
));
194 for (i
=0;i
<MAX_TEXTURE_UNITS
;i
++) {
195 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[i
];
197 if (!texUnit
->_ReallyEnabled
)
200 key
->unit
[i
].enabled
= 1;
201 key
->enabled_units
|= (1<<i
);
203 key
->unit
[i
].source_index
=
204 translate_tex_src_bit(texUnit
->_ReallyEnabled
);
206 key
->unit
[i
].NumArgsRGB
= texUnit
->_CurrentCombine
->_NumArgsRGB
;
207 key
->unit
[i
].NumArgsA
= texUnit
->_CurrentCombine
->_NumArgsA
;
209 key
->unit
[i
].ModeRGB
=
210 translate_mode(texUnit
->_CurrentCombine
->ModeRGB
);
212 translate_mode(texUnit
->_CurrentCombine
->ModeA
);
214 key
->unit
[i
].ScaleShiftRGB
= texUnit
->_CurrentCombine
->ScaleShiftRGB
;
215 key
->unit
[i
].ScaleShiftA
= texUnit
->_CurrentCombine
->ScaleShiftA
;
218 key
->unit
[i
].OptRGB
[j
].Operand
=
219 translate_operand(texUnit
->_CurrentCombine
->OperandRGB
[j
]);
220 key
->unit
[i
].OptA
[j
].Operand
=
221 translate_operand(texUnit
->_CurrentCombine
->OperandA
[j
]);
222 key
->unit
[i
].OptRGB
[j
].Source
=
223 translate_source(texUnit
->_CurrentCombine
->SourceRGB
[j
]);
224 key
->unit
[i
].OptA
[j
].Source
=
225 translate_source(texUnit
->_CurrentCombine
->SourceA
[j
]);
229 if (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
)
230 key
->separate_specular
= 1;
232 if (ctx
->Fog
.Enabled
) {
233 key
->fog_enabled
= 1;
234 key
->fog_mode
= translate_fog_mode(ctx
->Fog
.Mode
);
238 /* Use uregs to represent registers internally, translate to Mesa's
239 * expected formats on emit.
241 * NOTE: These are passed by value extensively in this file rather
242 * than as usual by pointer reference. If this disturbs you, try
243 * remembering they are just 32bits in size.
245 * GCC is smart enough to deal with these dword-sized structures in
246 * much the same way as if I had defined them as dwords and was using
247 * macros to access and set the fields. This is much nicer and easier
260 static const struct ureg undef
= {
271 /* State used to build the fragment program:
273 struct texenv_fragment_program
{
274 struct gl_fragment_program
*program
;
276 struct state_key
*state
;
278 GLbitfield alu_temps
; /* Track texture indirections, see spec. */
279 GLbitfield temps_output
; /* Track texture indirections, see spec. */
280 GLbitfield temp_in_use
; /* Tracks temporary regs which are in use. */
283 struct ureg src_texture
[MAX_TEXTURE_UNITS
];
284 /* Reg containing each texture unit's sampled texture color,
288 struct ureg src_previous
; /* Reg containing color from previous
289 * stage. May need to be decl'd.
292 GLuint last_tex_stage
; /* Number of last enabled texture unit */
301 static struct ureg
make_ureg(GLuint file
, GLuint idx
)
309 reg
.swz
= SWIZZLE_NOOP
;
314 static struct ureg
swizzle( struct ureg reg
, int x
, int y
, int z
, int w
)
316 reg
.swz
= MAKE_SWIZZLE4(GET_SWZ(reg
.swz
, x
),
319 GET_SWZ(reg
.swz
, w
));
324 static struct ureg
swizzle1( struct ureg reg
, int x
)
326 return swizzle(reg
, x
, x
, x
, x
);
329 static struct ureg
negate( struct ureg reg
)
335 static GLboolean
is_undef( struct ureg reg
)
337 return reg
.file
== PROGRAM_UNDEFINED
;
341 static struct ureg
get_temp( struct texenv_fragment_program
*p
)
345 /* First try and reuse temps which have been used already:
347 bit
= _mesa_ffs( ~p
->temp_in_use
& p
->alu_temps
);
349 /* Then any unused temporary:
352 bit
= _mesa_ffs( ~p
->temp_in_use
);
355 _mesa_problem(NULL
, "%s: out of temporaries\n", __FILE__
);
359 if ((GLuint
) bit
> p
->program
->Base
.NumTemporaries
)
360 p
->program
->Base
.NumTemporaries
= bit
;
362 p
->temp_in_use
|= 1<<(bit
-1);
363 return make_ureg(PROGRAM_TEMPORARY
, (bit
-1));
366 static struct ureg
get_tex_temp( struct texenv_fragment_program
*p
)
370 /* First try to find availble temp not previously used (to avoid
371 * starting a new texture indirection). According to the spec, the
372 * ~p->temps_output isn't necessary, but will keep it there for
375 bit
= _mesa_ffs( ~p
->temp_in_use
& ~p
->alu_temps
& ~p
->temps_output
);
377 /* Then any unused temporary:
380 bit
= _mesa_ffs( ~p
->temp_in_use
);
383 _mesa_problem(NULL
, "%s: out of temporaries\n", __FILE__
);
387 if ((GLuint
) bit
> p
->program
->Base
.NumTemporaries
)
388 p
->program
->Base
.NumTemporaries
= bit
;
390 p
->temp_in_use
|= 1<<(bit
-1);
391 return make_ureg(PROGRAM_TEMPORARY
, (bit
-1));
395 static void release_temps( struct texenv_fragment_program
*p
)
397 GLuint max_temp
= p
->ctx
->Const
.FragmentProgram
.MaxTemps
;
399 /* KW: To support tex_env_crossbar, don't release the registers in
402 if (max_temp
>= sizeof(int) * 8)
403 p
->temp_in_use
= p
->temps_output
;
405 p
->temp_in_use
= ~((1<<max_temp
)-1) | p
->temps_output
;
409 static struct ureg
register_param6( struct texenv_fragment_program
*p
,
425 idx
= _mesa_add_state_reference( p
->program
->Base
.Parameters
, tokens
);
426 return make_ureg(PROGRAM_STATE_VAR
, idx
);
430 #define register_param1(p,s0) register_param6(p,s0,0,0,0,0,0)
431 #define register_param2(p,s0,s1) register_param6(p,s0,s1,0,0,0,0)
432 #define register_param3(p,s0,s1,s2) register_param6(p,s0,s1,s2,0,0,0)
433 #define register_param4(p,s0,s1,s2,s3) register_param6(p,s0,s1,s2,s3,0,0)
436 static struct ureg
register_input( struct texenv_fragment_program
*p
, GLuint input
)
438 p
->program
->Base
.InputsRead
|= (1 << input
);
439 return make_ureg(PROGRAM_INPUT
, input
);
443 static void emit_arg( struct prog_src_register
*reg
,
446 reg
->File
= ureg
.file
;
447 reg
->Index
= ureg
.idx
;
448 reg
->Swizzle
= ureg
.swz
;
449 reg
->NegateBase
= ureg
.negatebase
? 0xf : 0x0;
451 reg
->NegateAbs
= ureg
.negateabs
;
454 static void emit_dst( struct prog_dst_register
*dst
,
455 struct ureg ureg
, GLuint mask
)
457 dst
->File
= ureg
.file
;
458 dst
->Index
= ureg
.idx
;
459 dst
->WriteMask
= mask
;
461 dst
->CondSwizzle
= 0;
464 static struct prog_instruction
*
465 emit_op(struct texenv_fragment_program
*p
,
474 GLuint nr
= p
->program
->Base
.NumInstructions
++;
475 struct prog_instruction
*inst
= &p
->program
->Base
.Instructions
[nr
];
477 _mesa_init_instruction(inst
);
480 emit_arg( &inst
->SrcReg
[0], src0
);
481 emit_arg( &inst
->SrcReg
[1], src1
);
482 emit_arg( &inst
->SrcReg
[2], src2
);
484 inst
->SaturateMode
= saturate
? SATURATE_ZERO_ONE
: SATURATE_OFF
;
486 emit_dst( &inst
->DstReg
, dest
, mask
);
488 /* Accounting for indirection tracking:
490 if (dest
.file
== PROGRAM_TEMPORARY
)
491 p
->temps_output
|= 1 << dest
.idx
;
497 static struct ureg
emit_arith( struct texenv_fragment_program
*p
,
506 emit_op(p
, op
, dest
, mask
, saturate
, src0
, src1
, src2
);
508 /* Accounting for indirection tracking:
510 if (src0
.file
== PROGRAM_TEMPORARY
)
511 p
->alu_temps
|= 1 << src0
.idx
;
513 if (!is_undef(src1
) && src1
.file
== PROGRAM_TEMPORARY
)
514 p
->alu_temps
|= 1 << src1
.idx
;
516 if (!is_undef(src2
) && src2
.file
== PROGRAM_TEMPORARY
)
517 p
->alu_temps
|= 1 << src2
.idx
;
519 if (dest
.file
== PROGRAM_TEMPORARY
)
520 p
->alu_temps
|= 1 << dest
.idx
;
522 p
->program
->NumAluInstructions
++;
526 static struct ureg
emit_texld( struct texenv_fragment_program
*p
,
534 struct prog_instruction
*inst
= emit_op( p
, op
,
536 GL_FALSE
, /* don't saturate? */
541 inst
->TexSrcTarget
= tex_idx
;
542 inst
->TexSrcUnit
= tex_unit
;
544 p
->program
->NumTexInstructions
++;
546 /* Is this a texture indirection?
548 if ((coord
.file
== PROGRAM_TEMPORARY
&&
549 (p
->temps_output
& (1<<coord
.idx
))) ||
550 (dest
.file
== PROGRAM_TEMPORARY
&&
551 (p
->alu_temps
& (1<<dest
.idx
)))) {
552 p
->program
->NumTexIndirections
++;
553 p
->temps_output
= 1<<coord
.idx
;
555 assert(0); /* KW: texture env crossbar */
562 static struct ureg
register_const4f( struct texenv_fragment_program
*p
,
574 idx
= _mesa_add_unnamed_constant( p
->program
->Base
.Parameters
, values
);
575 return make_ureg(PROGRAM_STATE_VAR
, idx
);
578 #define register_scalar_const(p, s0) register_const4f(p, s0, s0, s0, s0)
579 #define register_const1f(p, s0) register_const4f(p, s0, 0, 0, 1)
580 #define register_const2f(p, s0, s1) register_const4f(p, s0, s1, 0, 1)
581 #define register_const3f(p, s0, s1, s2) register_const4f(p, s0, s1, s2, 1)
584 static struct ureg
get_one( struct texenv_fragment_program
*p
)
586 if (is_undef(p
->one
))
587 p
->one
= register_scalar_const(p
, 1.0);
591 static struct ureg
get_half( struct texenv_fragment_program
*p
)
593 if (is_undef(p
->half
))
594 p
->half
= register_scalar_const(p
, 0.5);
598 static struct ureg
get_zero( struct texenv_fragment_program
*p
)
600 if (is_undef(p
->zero
))
601 p
->zero
= register_scalar_const(p
, 0.0);
606 static void program_error( struct texenv_fragment_program
*p
, const char *msg
)
608 _mesa_problem(NULL
, msg
);
612 static struct ureg
get_source( struct texenv_fragment_program
*p
,
613 GLuint src
, GLuint unit
)
617 assert(!is_undef(p
->src_texture
[unit
]));
618 return p
->src_texture
[unit
];
628 assert(!is_undef(p
->src_texture
[src
- SRC_TEXTURE0
]));
629 return p
->src_texture
[src
- SRC_TEXTURE0
];
632 return register_param2(p
, STATE_TEXENV_COLOR
, unit
);
634 case SRC_PRIMARY_COLOR
:
635 return register_input(p
, FRAG_ATTRIB_COL0
);
639 if (is_undef(p
->src_previous
))
640 return register_input(p
, FRAG_ATTRIB_COL0
);
642 return p
->src_previous
;
646 static struct ureg
emit_combine_source( struct texenv_fragment_program
*p
,
652 struct ureg arg
, src
, one
;
654 src
= get_source(p
, source
, unit
);
657 case OPR_ONE_MINUS_SRC_COLOR
:
659 * Emit tmp = 1.0 - arg.xyzw
663 return emit_arith( p
, OPCODE_SUB
, arg
, mask
, 0, one
, src
, undef
);
666 if (mask
== WRITEMASK_W
)
669 return swizzle1( src
, SWIZZLE_W
);
670 case OPR_ONE_MINUS_SRC_ALPHA
:
672 * Emit tmp = 1.0 - arg.wwww
676 return emit_arith(p
, OPCODE_SUB
, arg
, mask
, 0,
677 one
, swizzle1(src
, SWIZZLE_W
), undef
);
688 static GLboolean
args_match( struct state_key
*key
, GLuint unit
)
690 GLuint i
, nr
= key
->unit
[unit
].NumArgsRGB
;
692 for (i
= 0 ; i
< nr
; i
++) {
693 if (key
->unit
[unit
].OptA
[i
].Source
!= key
->unit
[unit
].OptRGB
[i
].Source
)
696 switch(key
->unit
[unit
].OptA
[i
].Operand
) {
698 switch(key
->unit
[unit
].OptRGB
[i
].Operand
) {
706 case OPR_ONE_MINUS_SRC_ALPHA
:
707 switch(key
->unit
[unit
].OptRGB
[i
].Operand
) {
708 case OPR_ONE_MINUS_SRC_COLOR
:
709 case OPR_ONE_MINUS_SRC_ALPHA
:
716 return GL_FALSE
; /* impossible */
723 static struct ureg
emit_combine( struct texenv_fragment_program
*p
,
730 const struct mode_opt
*opt
)
733 struct ureg tmp
, half
;
736 tmp
= undef
; /* silence warning (bug 5318) */
738 for (i
= 0; i
< nr
; i
++)
739 src
[i
] = emit_combine_source( p
, mask
, unit
, opt
[i
].Source
, opt
[i
].Operand
);
743 if (mask
== WRITEMASK_XYZW
&& !saturate
)
746 return emit_arith( p
, OPCODE_MOV
, dest
, mask
, saturate
, src
[0], undef
, undef
);
748 return emit_arith( p
, OPCODE_MUL
, dest
, mask
, saturate
,
749 src
[0], src
[1], undef
);
751 return emit_arith( p
, OPCODE_ADD
, dest
, mask
, saturate
,
752 src
[0], src
[1], undef
);
753 case MODE_ADD_SIGNED
:
759 emit_arith( p
, OPCODE_ADD
, tmp
, mask
, 0, src
[0], src
[1], undef
);
760 emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, tmp
, half
, undef
);
762 case MODE_INTERPOLATE
:
763 /* Arg0 * (Arg2) + Arg1 * (1-Arg2) -- note arguments are reordered:
765 return emit_arith( p
, OPCODE_LRP
, dest
, mask
, saturate
, src
[2], src
[0], src
[1] );
768 return emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, src
[0], src
[1], undef
);
771 case MODE_DOT3_RGBA_EXT
:
772 case MODE_DOT3_RGB_EXT
:
773 case MODE_DOT3_RGB
: {
774 struct ureg tmp0
= get_temp( p
);
775 struct ureg tmp1
= get_temp( p
);
776 struct ureg neg1
= register_scalar_const(p
, -1);
777 struct ureg two
= register_scalar_const(p
, 2);
782 * dst = tmp0 dot3 tmp1
784 emit_arith( p
, OPCODE_MAD
, tmp0
, WRITEMASK_XYZW
, 0,
787 if (_mesa_memcmp(&src
[0], &src
[1], sizeof(struct ureg
)) == 0)
790 emit_arith( p
, OPCODE_MAD
, tmp1
, WRITEMASK_XYZW
, 0,
792 emit_arith( p
, OPCODE_DP3
, dest
, mask
, saturate
, tmp0
, tmp1
, undef
);
795 case MODE_MODULATE_ADD_ATI
:
796 /* Arg0 * Arg2 + Arg1 */
797 return emit_arith( p
, OPCODE_MAD
, dest
, mask
, saturate
,
798 src
[0], src
[2], src
[1] );
799 case MODE_MODULATE_SIGNED_ADD_ATI
: {
800 /* Arg0 * Arg2 + Arg1 - 0.5 */
801 struct ureg tmp0
= get_temp(p
);
803 emit_arith( p
, OPCODE_MAD
, tmp0
, mask
, 0, src
[0], src
[2], src
[1] );
804 emit_arith( p
, OPCODE_SUB
, dest
, mask
, saturate
, tmp0
, half
, undef
);
807 case MODE_MODULATE_SUBTRACT_ATI
:
808 /* Arg0 * Arg2 - Arg1 */
809 emit_arith( p
, OPCODE_MAD
, dest
, mask
, 0, src
[0], src
[2], negate(src
[1]) );
818 * Generate instructions for one texture unit's env/combiner mode.
821 emit_texenv(struct texenv_fragment_program
*p
, GLuint unit
)
823 struct state_key
*key
= p
->state
;
824 GLboolean saturate
= (unit
< p
->last_tex_stage
);
825 GLuint rgb_shift
, alpha_shift
;
826 struct ureg out
, shift
;
829 if (!key
->unit
[unit
].enabled
) {
830 return get_source(p
, SRC_PREVIOUS
, 0);
833 switch (key
->unit
[unit
].ModeRGB
) {
834 case MODE_DOT3_RGB_EXT
:
835 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
838 case MODE_DOT3_RGBA_EXT
:
843 rgb_shift
= key
->unit
[unit
].ScaleShiftRGB
;
844 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
848 /* If this is the very last calculation, emit direct to output reg:
850 if (key
->separate_specular
||
851 unit
!= p
->last_tex_stage
||
854 dest
= get_temp( p
);
856 dest
= make_ureg(PROGRAM_OUTPUT
, FRAG_RESULT_COLR
);
858 /* Emit the RGB and A combine ops
860 if (key
->unit
[unit
].ModeRGB
== key
->unit
[unit
].ModeA
&&
861 args_match(key
, unit
)) {
862 out
= emit_combine( p
, dest
, WRITEMASK_XYZW
, saturate
,
864 key
->unit
[unit
].NumArgsRGB
,
865 key
->unit
[unit
].ModeRGB
,
866 key
->unit
[unit
].OptRGB
);
868 else if (key
->unit
[unit
].ModeRGB
== MODE_DOT3_RGBA_EXT
||
869 key
->unit
[unit
].ModeA
== MODE_DOT3_RGBA
) {
871 out
= emit_combine( p
, dest
, WRITEMASK_XYZW
, saturate
,
873 key
->unit
[unit
].NumArgsRGB
,
874 key
->unit
[unit
].ModeRGB
,
875 key
->unit
[unit
].OptRGB
);
878 /* Need to do something to stop from re-emitting identical
879 * argument calculations here:
881 out
= emit_combine( p
, dest
, WRITEMASK_XYZ
, saturate
,
883 key
->unit
[unit
].NumArgsRGB
,
884 key
->unit
[unit
].ModeRGB
,
885 key
->unit
[unit
].OptRGB
);
886 out
= emit_combine( p
, dest
, WRITEMASK_W
, saturate
,
888 key
->unit
[unit
].NumArgsA
,
889 key
->unit
[unit
].ModeA
,
890 key
->unit
[unit
].OptA
);
893 /* Deal with the final shift:
895 if (alpha_shift
|| rgb_shift
) {
896 if (rgb_shift
== alpha_shift
) {
897 shift
= register_scalar_const(p
, 1<<rgb_shift
);
900 shift
= register_const4f(p
,
906 return emit_arith( p
, OPCODE_MUL
, dest
, WRITEMASK_XYZW
,
907 saturate
, out
, shift
, undef
);
915 * Generate instruction for getting a texture source term.
917 static void load_texture( struct texenv_fragment_program
*p
, GLuint unit
)
919 if (is_undef(p
->src_texture
[unit
])) {
920 GLuint dim
= p
->state
->unit
[unit
].source_index
;
921 struct ureg texcoord
= register_input(p
, FRAG_ATTRIB_TEX0
+unit
);
922 struct ureg tmp
= get_tex_temp( p
);
924 if (dim
== TEXTURE_UNKNOWN_INDEX
)
925 program_error(p
, "TexSrcBit");
927 /* TODO: Use D0_MASK_XY where possible.
929 if (p
->state
->unit
[unit
].enabled
)
930 p
->src_texture
[unit
] = emit_texld( p
, OPCODE_TXP
,
932 unit
, dim
, texcoord
);
934 p
->src_texture
[unit
] = get_zero(p
);
938 static GLboolean
load_texenv_source( struct texenv_fragment_program
*p
,
939 GLuint src
, GLuint unit
)
943 load_texture(p
, unit
);
954 load_texture(p
, src
- SRC_TEXTURE0
);
966 * Generate instructions for loading all texture source terms.
969 load_texunit_sources( struct texenv_fragment_program
*p
, int unit
)
971 struct state_key
*key
= p
->state
;
974 for (i
= 0; i
< key
->unit
[unit
].NumArgsRGB
; i
++) {
975 load_texenv_source( p
, key
->unit
[unit
].OptRGB
[i
].Source
, unit
);
978 for (i
= 0; i
< key
->unit
[unit
].NumArgsA
; i
++) {
979 load_texenv_source( p
, key
->unit
[unit
].OptA
[i
].Source
, unit
);
987 * Generate a new fragment program which implements the context's
988 * current texture env/combine mode.
991 create_new_program(struct state_key
*key
, GLcontext
*ctx
,
992 struct gl_fragment_program
*program
)
994 struct texenv_fragment_program p
;
998 _mesa_memset(&p
, 0, sizeof(p
));
1001 p
.program
= program
;
1003 p
.program
->Base
.Instructions
=
1004 (struct prog_instruction
*) _mesa_malloc(sizeof(struct prog_instruction
) * MAX_INSTRUCTIONS
);
1005 p
.program
->Base
.NumInstructions
= 0;
1006 p
.program
->Base
.Target
= GL_FRAGMENT_PROGRAM_ARB
;
1007 p
.program
->NumTexIndirections
= 1; /* correct? */
1008 p
.program
->NumTexInstructions
= 0;
1009 p
.program
->NumAluInstructions
= 0;
1010 p
.program
->Base
.String
= 0;
1011 p
.program
->Base
.NumInstructions
=
1012 p
.program
->Base
.NumTemporaries
=
1013 p
.program
->Base
.NumParameters
=
1014 p
.program
->Base
.NumAttributes
= p
.program
->Base
.NumAddressRegs
= 0;
1015 p
.program
->Base
.Parameters
= _mesa_new_parameter_list();
1017 p
.program
->Base
.InputsRead
= 0;
1018 p
.program
->Base
.OutputsWritten
= 1 << FRAG_RESULT_COLR
;
1020 for (unit
= 0; unit
< MAX_TEXTURE_UNITS
; unit
++)
1021 p
.src_texture
[unit
] = undef
;
1023 p
.src_previous
= undef
;
1028 p
.last_tex_stage
= 0;
1031 if (key
->enabled_units
) {
1032 /* First pass - to support texture_env_crossbar, first identify
1033 * all referenced texture sources and emit texld instructions
1036 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++)
1037 if (key
->unit
[unit
].enabled
) {
1038 load_texunit_sources( &p
, unit
);
1039 p
.last_tex_stage
= unit
;
1042 /* Second pass - emit combine instructions to build final color:
1044 for (unit
= 0 ; unit
< ctx
->Const
.MaxTextureUnits
; unit
++)
1045 if (key
->enabled_units
& (1<<unit
)) {
1046 p
.src_previous
= emit_texenv( &p
, unit
);
1047 release_temps(&p
); /* release all temps */
1051 cf
= get_source( &p
, SRC_PREVIOUS
, 0 );
1052 out
= make_ureg( PROGRAM_OUTPUT
, FRAG_RESULT_COLR
);
1054 if (key
->separate_specular
) {
1055 /* Emit specular add.
1057 struct ureg s
= register_input(&p
, FRAG_ATTRIB_COL1
);
1058 emit_arith( &p
, OPCODE_ADD
, out
, WRITEMASK_XYZ
, 0, cf
, s
, undef
);
1059 emit_arith( &p
, OPCODE_MOV
, out
, WRITEMASK_W
, 0, cf
, undef
, undef
);
1061 else if (_mesa_memcmp(&cf
, &out
, sizeof(cf
)) != 0) {
1062 /* Will wind up in here if no texture enabled or a couple of
1063 * other scenarios (GL_REPLACE for instance).
1065 emit_arith( &p
, OPCODE_MOV
, out
, WRITEMASK_XYZW
, 0, cf
, undef
, undef
);
1070 emit_arith( &p
, OPCODE_END
, undef
, WRITEMASK_XYZW
, 0, undef
, undef
, undef
);
1072 if (key
->fog_enabled
) {
1073 /* Pull fog mode from GLcontext, the value in the state key is
1074 * a reduced value and not what is expected in FogOption
1076 p
.program
->FogOption
= ctx
->Fog
.Mode
;
1078 p
.program
->FogOption
= GL_NONE
;
1080 if (p
.program
->NumTexIndirections
> ctx
->Const
.FragmentProgram
.MaxTexIndirections
)
1081 program_error(&p
, "Exceeded max nr indirect texture lookups");
1083 if (p
.program
->NumTexInstructions
> ctx
->Const
.FragmentProgram
.MaxTexInstructions
)
1084 program_error(&p
, "Exceeded max TEX instructions");
1086 if (p
.program
->NumAluInstructions
> ctx
->Const
.FragmentProgram
.MaxAluInstructions
)
1087 program_error(&p
, "Exceeded max ALU instructions");
1089 ASSERT(p
.program
->Base
.NumInstructions
<= MAX_INSTRUCTIONS
);
1091 /* Notify driver the fragment program has (actually) changed.
1093 if (ctx
->Driver
.ProgramStringNotify
|| DISASSEM
) {
1094 if (ctx
->Driver
.ProgramStringNotify
)
1095 ctx
->Driver
.ProgramStringNotify( ctx
, GL_FRAGMENT_PROGRAM_ARB
,
1099 _mesa_print_program(&p
.program
->Base
);
1106 static struct gl_fragment_program
*
1107 search_cache(const struct texenvprog_cache
*cache
,
1112 struct texenvprog_cache_item
*c
;
1114 for (c
= cache
->items
[hash
% cache
->size
]; c
; c
= c
->next
) {
1115 if (c
->hash
== hash
&& memcmp(c
->key
, key
, keysize
) == 0)
1116 return (struct gl_fragment_program
*) c
->data
;
1122 static void rehash( struct texenvprog_cache
*cache
)
1124 struct texenvprog_cache_item
**items
;
1125 struct texenvprog_cache_item
*c
, *next
;
1128 size
= cache
->size
* 3;
1129 items
= (struct texenvprog_cache_item
**) _mesa_malloc(size
* sizeof(*items
));
1130 _mesa_memset(items
, 0, size
* sizeof(*items
));
1132 for (i
= 0; i
< cache
->size
; i
++)
1133 for (c
= cache
->items
[i
]; c
; c
= next
) {
1135 c
->next
= items
[c
->hash
% size
];
1136 items
[c
->hash
% size
] = c
;
1139 _mesa_free(cache
->items
);
1140 cache
->items
= items
;
1144 static void clear_cache( struct texenvprog_cache
*cache
)
1146 struct texenvprog_cache_item
*c
, *next
;
1149 for (i
= 0; i
< cache
->size
; i
++) {
1150 for (c
= cache
->items
[i
]; c
; c
= next
) {
1153 cache
->ctx
->Driver
.DeleteProgram(cache
->ctx
,
1154 (struct gl_program
*) c
->data
);
1157 cache
->items
[i
] = NULL
;
1165 static void cache_item( struct texenvprog_cache
*cache
,
1167 const struct state_key
*key
,
1170 struct texenvprog_cache_item
*c
= MALLOC(sizeof(*c
));
1173 c
->key
= _mesa_malloc(sizeof(*key
));
1174 memcpy(c
->key
, key
, sizeof(*key
));
1178 if (cache
->n_items
> cache
->size
* 1.5) {
1179 if (cache
->size
< 1000)
1186 c
->next
= cache
->items
[hash
% cache
->size
];
1187 cache
->items
[hash
% cache
->size
] = c
;
1190 static GLuint
hash_key( const struct state_key
*key
)
1192 GLuint
*ikey
= (GLuint
*)key
;
1195 /* Make a slightly better attempt at a hash function:
1197 for (i
= 0; i
< sizeof(*key
)/sizeof(*ikey
); i
++)
1200 hash
+= (hash
<< 10);
1201 hash
^= (hash
>> 6);
1207 void _mesa_UpdateTexEnvProgram( GLcontext
*ctx
)
1209 struct state_key key
;
1211 const struct gl_fragment_program
*prev
= ctx
->FragmentProgram
._Current
;
1213 if (!ctx
->FragmentProgram
._Enabled
) {
1214 make_state_key(ctx
, &key
);
1215 hash
= hash_key(&key
);
1217 ctx
->FragmentProgram
._Current
=
1218 ctx
->_TexEnvProgram
=
1219 search_cache(&ctx
->Texture
.env_fp_cache
, hash
, &key
, sizeof(key
));
1221 if (!ctx
->_TexEnvProgram
) {
1222 if (0) _mesa_printf("Building new texenv proggy for key %x\n", hash
);
1224 ctx
->FragmentProgram
._Current
= ctx
->_TexEnvProgram
=
1225 (struct gl_fragment_program
*)
1226 ctx
->Driver
.NewProgram(ctx
, GL_FRAGMENT_PROGRAM_ARB
, 0);
1228 create_new_program(&key
, ctx
, ctx
->_TexEnvProgram
);
1230 cache_item(&ctx
->Texture
.env_fp_cache
, hash
, &key
, ctx
->_TexEnvProgram
);
1232 if (0) _mesa_printf("Found existing texenv program for key %x\n", hash
);
1236 ctx
->FragmentProgram
._Current
= ctx
->FragmentProgram
.Current
;
1239 /* Tell the driver about the change. Could define a new target for
1242 if (ctx
->FragmentProgram
._Current
!= prev
&& ctx
->Driver
.BindProgram
) {
1243 ctx
->Driver
.BindProgram(ctx
, GL_FRAGMENT_PROGRAM_ARB
,
1244 (struct gl_program
*) ctx
->FragmentProgram
._Current
);
1249 void _mesa_TexEnvProgramCacheInit( GLcontext
*ctx
)
1251 ctx
->Texture
.env_fp_cache
.ctx
= ctx
;
1252 ctx
->Texture
.env_fp_cache
.size
= 17;
1253 ctx
->Texture
.env_fp_cache
.n_items
= 0;
1254 ctx
->Texture
.env_fp_cache
.items
= (struct texenvprog_cache_item
**)
1255 _mesa_calloc(ctx
->Texture
.env_fp_cache
.size
*
1256 sizeof(struct texenvprog_cache_item
));
1260 void _mesa_TexEnvProgramCacheDestroy( GLcontext
*ctx
)
1262 clear_cache(&ctx
->Texture
.env_fp_cache
);
1263 _mesa_free(ctx
->Texture
.env_fp_cache
.items
);