1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
5 * Copyright 2009 VMware, Inc. All Rights Reserved.
6 * Copyright © 2010-2011 Intel Corporation
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the
10 * "Software"), to deal in the Software without restriction, including
11 * without limitation the rights to use, copy, modify, merge, publish,
12 * distribute, sub license, and/or sell copies of the Software, and to
13 * permit persons to whom the Software is furnished to do so, subject to
14 * the following conditions:
16 * The above copyright notice and this permission notice (including the
17 * next paragraph) shall be included in all copies or substantial portions
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
23 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
24 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
25 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
26 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 **************************************************************************/
30 #include "main/glheader.h"
31 #include "main/context.h"
32 #include "main/imports.h"
33 #include "main/macros.h"
34 #include "main/samplerobj.h"
35 #include "main/shaderobj.h"
36 #include "main/state.h"
37 #include "main/texenvprogram.h"
38 #include "main/texobj.h"
39 #include "main/uniforms.h"
40 #include "compiler/glsl/ir_builder.h"
41 #include "compiler/glsl/ir_optimization.h"
42 #include "compiler/glsl/glsl_parser_extras.h"
43 #include "compiler/glsl/glsl_symbol_table.h"
44 #include "compiler/glsl_types.h"
45 #include "program/ir_to_mesa.h"
46 #include "program/program.h"
47 #include "program/programopt.h"
48 #include "program/prog_cache.h"
49 #include "program/prog_instruction.h"
50 #include "program/prog_parameter.h"
51 #include "program/prog_print.h"
52 #include "program/prog_statevars.h"
53 #include "util/bitscan.h"
55 using namespace ir_builder
;
58 * Note on texture units:
60 * The number of texture units supported by fixed-function fragment
61 * processing is MAX_TEXTURE_COORD_UNITS, not MAX_TEXTURE_IMAGE_UNITS.
62 * That's because there's a one-to-one correspondence between texture
63 * coordinates and samplers in fixed-function processing.
65 * Since fixed-function vertex processing is limited to MAX_TEXTURE_COORD_UNITS
66 * sets of texcoords, so is fixed-function fragment processing.
68 * We can safely use ctx->Const.MaxTextureUnits for loop bounds.
73 texenv_doing_secondary_color(struct gl_context
*ctx
)
75 if (ctx
->Light
.Enabled
&&
76 (ctx
->Light
.Model
.ColorControl
== GL_SEPARATE_SPECULAR_COLOR
))
79 if (ctx
->Fog
.ColorSumEnabled
)
86 GLuint nr_enabled_units
:4;
87 GLuint separate_specular
:1;
88 GLuint fog_mode
:2; /**< FOG_x */
89 GLuint inputs_available
:12;
90 GLuint num_draw_buffers
:4;
92 /* NOTE: This array of structs must be last! (see "keySize" below) */
95 GLuint source_index
:4; /**< TEXTURE_x_INDEX */
99 * These are taken from struct gl_tex_env_combine_packed
104 GLuint ScaleShiftRGB
:2;
105 GLuint ScaleShiftA
:2;
108 struct gl_tex_env_argument ArgsRGB
[MAX_COMBINER_TERMS
];
109 struct gl_tex_env_argument ArgsA
[MAX_COMBINER_TERMS
];
111 } unit
[MAX_TEXTURE_COORD_UNITS
];
116 * Do we need to clamp the results of the given texture env/combine mode?
117 * If the inputs to the mode are in [0,1] we don't always have to clamp
121 need_saturate( GLuint mode
)
124 case TEXENV_MODE_REPLACE
:
125 case TEXENV_MODE_MODULATE
:
126 case TEXENV_MODE_INTERPOLATE
:
128 case TEXENV_MODE_ADD
:
129 case TEXENV_MODE_ADD_SIGNED
:
130 case TEXENV_MODE_SUBTRACT
:
131 case TEXENV_MODE_DOT3_RGB
:
132 case TEXENV_MODE_DOT3_RGB_EXT
:
133 case TEXENV_MODE_DOT3_RGBA
:
134 case TEXENV_MODE_DOT3_RGBA_EXT
:
135 case TEXENV_MODE_MODULATE_ADD_ATI
:
136 case TEXENV_MODE_MODULATE_SIGNED_ADD_ATI
:
137 case TEXENV_MODE_MODULATE_SUBTRACT_ATI
:
138 case TEXENV_MODE_ADD_PRODUCTS_NV
:
139 case TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV
:
147 #define VERT_BIT_TEX_ANY (0xff << VERT_ATTRIB_TEX0)
150 * Identify all possible varying inputs. The fragment program will
151 * never reference non-varying inputs, but will track them via state
154 * This function figures out all the inputs that the fragment program
155 * has access to and filters input bitmask.
157 static GLbitfield
filter_fp_input_mask( GLbitfield fp_inputs
,
158 struct gl_context
*ctx
)
160 if (ctx
->VertexProgram
._Overriden
) {
161 /* Somebody's messing with the vertex program and we don't have
162 * a clue what's happening. Assume that it could be producing
163 * all possible outputs.
168 if (ctx
->RenderMode
== GL_FEEDBACK
) {
169 /* _NEW_RENDERMODE */
170 return fp_inputs
& (VARYING_BIT_COL0
| VARYING_BIT_TEX0
);
174 const GLboolean vertexShader
=
175 ctx
->_Shader
->CurrentProgram
[MESA_SHADER_VERTEX
] != NULL
;
176 const GLboolean vertexProgram
= _mesa_arb_vertex_program_enabled(ctx
);
178 if (!(vertexProgram
|| vertexShader
)) {
179 /* Fixed function vertex logic */
180 GLbitfield possible_inputs
= 0;
182 /* _NEW_VARYING_VP_INPUTS */
183 GLbitfield varying_inputs
= ctx
->varying_vp_inputs
;
185 /* These get generated in the setup routine regardless of the
189 if (ctx
->Point
.PointSprite
) {
190 /* All texture varyings are possible to use */
191 possible_inputs
= VARYING_BITS_TEX_ANY
;
194 /* _NEW_TEXTURE_STATE */
195 const GLbitfield possible_tex_inputs
=
196 ctx
->Texture
._TexGenEnabled
|
197 ctx
->Texture
._TexMatEnabled
|
198 ((varying_inputs
& VERT_BIT_TEX_ANY
) >> VERT_ATTRIB_TEX0
);
200 possible_inputs
= (possible_tex_inputs
<< VARYING_SLOT_TEX0
);
203 /* First look at what values may be computed by the generated
207 if (ctx
->Light
.Enabled
) {
208 possible_inputs
|= VARYING_BIT_COL0
;
210 if (texenv_doing_secondary_color(ctx
))
211 possible_inputs
|= VARYING_BIT_COL1
;
214 /* Then look at what might be varying as a result of enabled
217 if (varying_inputs
& VERT_BIT_COLOR0
)
218 possible_inputs
|= VARYING_BIT_COL0
;
219 if (varying_inputs
& VERT_BIT_COLOR1
)
220 possible_inputs
|= VARYING_BIT_COL1
;
222 return fp_inputs
& possible_inputs
;
225 /* calculate from vp->outputs */
226 struct gl_program
*vprog
;
228 /* Choose GLSL vertex shader over ARB vertex program. Need this
229 * since vertex shader state validation comes after fragment state
230 * validation (see additional comments in state.c).
232 if (ctx
->_Shader
->CurrentProgram
[MESA_SHADER_GEOMETRY
] != NULL
)
233 vprog
= ctx
->_Shader
->CurrentProgram
[MESA_SHADER_GEOMETRY
];
234 else if (ctx
->_Shader
->CurrentProgram
[MESA_SHADER_TESS_EVAL
] != NULL
)
235 vprog
= ctx
->_Shader
->CurrentProgram
[MESA_SHADER_TESS_EVAL
];
236 else if (vertexShader
)
237 vprog
= ctx
->_Shader
->CurrentProgram
[MESA_SHADER_VERTEX
];
239 vprog
= ctx
->VertexProgram
.Current
;
241 GLbitfield possible_inputs
= vprog
->info
.outputs_written
;
243 /* These get generated in the setup routine regardless of the
247 if (ctx
->Point
.PointSprite
) {
248 /* All texture varyings are possible to use */
249 possible_inputs
|= VARYING_BITS_TEX_ANY
;
252 return fp_inputs
& possible_inputs
;
257 * Examine current texture environment state and generate a unique
258 * key to identify it.
260 static GLuint
make_state_key( struct gl_context
*ctx
, struct state_key
*key
)
262 GLbitfield inputs_referenced
= VARYING_BIT_COL0
;
266 memset(key
, 0, sizeof(*key
));
268 /* _NEW_TEXTURE_OBJECT */
269 mask
= ctx
->Texture
._EnabledCoordUnits
;
272 i
= u_bit_scan(&mask
);
273 const struct gl_texture_unit
*texUnit
= &ctx
->Texture
.Unit
[i
];
274 const struct gl_texture_object
*texObj
= texUnit
->_Current
;
275 const struct gl_tex_env_combine_packed
*comb
=
276 &ctx
->Texture
.FixedFuncUnit
[i
]._CurrentCombinePacked
;
281 key
->unit
[i
].enabled
= 1;
282 inputs_referenced
|= VARYING_BIT_TEX(i
);
284 key
->unit
[i
].source_index
= texObj
->TargetIndex
;
286 const struct gl_sampler_object
*samp
= _mesa_get_samplerobj(ctx
, i
);
287 if (samp
->CompareMode
== GL_COMPARE_R_TO_TEXTURE
) {
288 const GLenum format
= _mesa_texture_base_format(texObj
);
289 key
->unit
[i
].shadow
= (format
== GL_DEPTH_COMPONENT
||
290 format
== GL_DEPTH_STENCIL_EXT
);
293 key
->unit
[i
].ModeRGB
= comb
->ModeRGB
;
294 key
->unit
[i
].ModeA
= comb
->ModeA
;
295 key
->unit
[i
].ScaleShiftRGB
= comb
->ScaleShiftRGB
;
296 key
->unit
[i
].ScaleShiftA
= comb
->ScaleShiftA
;
297 key
->unit
[i
].NumArgsRGB
= comb
->NumArgsRGB
;
298 key
->unit
[i
].NumArgsA
= comb
->NumArgsA
;
300 memcpy(key
->unit
[i
].ArgsRGB
, comb
->ArgsRGB
, sizeof comb
->ArgsRGB
);
301 memcpy(key
->unit
[i
].ArgsA
, comb
->ArgsA
, sizeof comb
->ArgsA
);
304 key
->nr_enabled_units
= i
+ 1;
306 /* _NEW_LIGHT | _NEW_FOG */
307 if (texenv_doing_secondary_color(ctx
)) {
308 key
->separate_specular
= 1;
309 inputs_referenced
|= VARYING_BIT_COL1
;
313 key
->fog_mode
= ctx
->Fog
._PackedEnabledMode
;
316 key
->num_draw_buffers
= ctx
->DrawBuffer
->_NumColorDrawBuffers
;
319 if (ctx
->Color
.AlphaEnabled
&& key
->num_draw_buffers
== 0) {
320 /* if alpha test is enabled we need to emit at least one color */
321 key
->num_draw_buffers
= 1;
324 key
->inputs_available
= filter_fp_input_mask(inputs_referenced
, ctx
);
326 /* compute size of state key, ignoring unused texture units */
327 keySize
= sizeof(*key
) - sizeof(key
->unit
)
328 + key
->nr_enabled_units
* sizeof(key
->unit
[0]);
334 /** State used to build the fragment program:
336 class texenv_fragment_program
: public ir_factory
{
338 struct gl_shader_program
*shader_program
;
339 struct gl_shader
*shader
;
340 exec_list
*top_instructions
;
341 struct state_key
*state
;
343 ir_variable
*src_texture
[MAX_TEXTURE_COORD_UNITS
];
344 /* Reg containing each texture unit's sampled texture color,
348 /* Texcoord override from bumpmapping. */
349 ir_variable
*texcoord_tex
[MAX_TEXTURE_COORD_UNITS
];
351 /* Reg containing texcoord for a texture unit,
352 * needed for bump mapping, else undef.
355 ir_rvalue
*src_previous
; /**< Reg containing color from previous
356 * stage. May need to be decl'd.
361 get_current_attrib(texenv_fragment_program
*p
, GLuint attrib
)
363 ir_variable
*current
;
366 current
= p
->shader
->symbols
->get_variable("gl_CurrentAttribFragMESA");
368 current
->data
.max_array_access
= MAX2(current
->data
.max_array_access
, (int)attrib
);
369 val
= new(p
->mem_ctx
) ir_dereference_variable(current
);
370 ir_rvalue
*index
= new(p
->mem_ctx
) ir_constant(attrib
);
371 return new(p
->mem_ctx
) ir_dereference_array(val
, index
);
375 get_gl_Color(texenv_fragment_program
*p
)
377 if (p
->state
->inputs_available
& VARYING_BIT_COL0
) {
378 ir_variable
*var
= p
->shader
->symbols
->get_variable("gl_Color");
380 return new(p
->mem_ctx
) ir_dereference_variable(var
);
382 return get_current_attrib(p
, VERT_ATTRIB_COLOR0
);
387 get_source(texenv_fragment_program
*p
,
388 GLuint src
, GLuint unit
)
391 ir_dereference
*deref
;
394 case TEXENV_SRC_TEXTURE
:
395 return new(p
->mem_ctx
) ir_dereference_variable(p
->src_texture
[unit
]);
397 case TEXENV_SRC_TEXTURE0
:
398 case TEXENV_SRC_TEXTURE1
:
399 case TEXENV_SRC_TEXTURE2
:
400 case TEXENV_SRC_TEXTURE3
:
401 case TEXENV_SRC_TEXTURE4
:
402 case TEXENV_SRC_TEXTURE5
:
403 case TEXENV_SRC_TEXTURE6
:
404 case TEXENV_SRC_TEXTURE7
:
405 return new(p
->mem_ctx
)
406 ir_dereference_variable(p
->src_texture
[src
- TEXENV_SRC_TEXTURE0
]);
408 case TEXENV_SRC_CONSTANT
:
409 var
= p
->shader
->symbols
->get_variable("gl_TextureEnvColor");
411 deref
= new(p
->mem_ctx
) ir_dereference_variable(var
);
412 var
->data
.max_array_access
= MAX2(var
->data
.max_array_access
, (int)unit
);
413 return new(p
->mem_ctx
) ir_dereference_array(deref
,
414 new(p
->mem_ctx
) ir_constant(unit
));
416 case TEXENV_SRC_PRIMARY_COLOR
:
417 var
= p
->shader
->symbols
->get_variable("gl_Color");
419 return new(p
->mem_ctx
) ir_dereference_variable(var
);
421 case TEXENV_SRC_ZERO
:
422 return new(p
->mem_ctx
) ir_constant(0.0f
);
425 return new(p
->mem_ctx
) ir_constant(1.0f
);
427 case TEXENV_SRC_PREVIOUS
:
428 if (!p
->src_previous
) {
429 return get_gl_Color(p
);
431 return p
->src_previous
->clone(p
->mem_ctx
, NULL
);
441 emit_combine_source(texenv_fragment_program
*p
,
448 src
= get_source(p
, source
, unit
);
451 case TEXENV_OPR_ONE_MINUS_COLOR
:
452 return sub(new(p
->mem_ctx
) ir_constant(1.0f
), src
);
454 case TEXENV_OPR_ALPHA
:
455 return src
->type
->is_scalar() ? src
: swizzle_w(src
);
457 case TEXENV_OPR_ONE_MINUS_ALPHA
: {
458 ir_rvalue
*const scalar
= src
->type
->is_scalar() ? src
: swizzle_w(src
);
460 return sub(new(p
->mem_ctx
) ir_constant(1.0f
), scalar
);
463 case TEXENV_OPR_COLOR
:
473 * Check if the RGB and Alpha sources and operands match for the given
474 * texture unit's combinder state. When the RGB and A sources and
475 * operands match, we can emit fewer instructions.
477 static GLboolean
args_match( const struct state_key
*key
, GLuint unit
)
479 GLuint i
, numArgs
= key
->unit
[unit
].NumArgsRGB
;
481 for (i
= 0; i
< numArgs
; i
++) {
482 if (key
->unit
[unit
].ArgsA
[i
].Source
!= key
->unit
[unit
].ArgsRGB
[i
].Source
)
485 switch (key
->unit
[unit
].ArgsA
[i
].Operand
) {
486 case TEXENV_OPR_ALPHA
:
487 switch (key
->unit
[unit
].ArgsRGB
[i
].Operand
) {
488 case TEXENV_OPR_COLOR
:
489 case TEXENV_OPR_ALPHA
:
495 case TEXENV_OPR_ONE_MINUS_ALPHA
:
496 switch (key
->unit
[unit
].ArgsRGB
[i
].Operand
) {
497 case TEXENV_OPR_ONE_MINUS_COLOR
:
498 case TEXENV_OPR_ONE_MINUS_ALPHA
:
505 return GL_FALSE
; /* impossible */
513 smear(ir_rvalue
*val
)
515 if (!val
->type
->is_scalar())
518 return swizzle_xxxx(val
);
522 emit_combine(texenv_fragment_program
*p
,
526 const struct gl_tex_env_argument
*opt
)
528 ir_rvalue
*src
[MAX_COMBINER_TERMS
];
529 ir_rvalue
*tmp0
, *tmp1
;
532 assert(nr
<= MAX_COMBINER_TERMS
);
534 for (i
= 0; i
< nr
; i
++)
535 src
[i
] = emit_combine_source( p
, unit
, opt
[i
].Source
, opt
[i
].Operand
);
538 case TEXENV_MODE_REPLACE
:
541 case TEXENV_MODE_MODULATE
:
542 return mul(src
[0], src
[1]);
544 case TEXENV_MODE_ADD
:
545 return add(src
[0], src
[1]);
547 case TEXENV_MODE_ADD_SIGNED
:
548 return add(add(src
[0], src
[1]), new(p
->mem_ctx
) ir_constant(-0.5f
));
550 case TEXENV_MODE_INTERPOLATE
:
551 /* Arg0 * (Arg2) + Arg1 * (1-Arg2) */
552 tmp0
= mul(src
[0], src
[2]);
553 tmp1
= mul(src
[1], sub(new(p
->mem_ctx
) ir_constant(1.0f
),
554 src
[2]->clone(p
->mem_ctx
, NULL
)));
555 return add(tmp0
, tmp1
);
557 case TEXENV_MODE_SUBTRACT
:
558 return sub(src
[0], src
[1]);
560 case TEXENV_MODE_DOT3_RGBA
:
561 case TEXENV_MODE_DOT3_RGBA_EXT
:
562 case TEXENV_MODE_DOT3_RGB_EXT
:
563 case TEXENV_MODE_DOT3_RGB
: {
564 tmp0
= mul(src
[0], new(p
->mem_ctx
) ir_constant(2.0f
));
565 tmp0
= add(tmp0
, new(p
->mem_ctx
) ir_constant(-1.0f
));
567 tmp1
= mul(src
[1], new(p
->mem_ctx
) ir_constant(2.0f
));
568 tmp1
= add(tmp1
, new(p
->mem_ctx
) ir_constant(-1.0f
));
570 return dot(swizzle_xyz(smear(tmp0
)), swizzle_xyz(smear(tmp1
)));
572 case TEXENV_MODE_MODULATE_ADD_ATI
:
573 return add(mul(src
[0], src
[2]), src
[1]);
575 case TEXENV_MODE_MODULATE_SIGNED_ADD_ATI
:
576 return add(add(mul(src
[0], src
[2]), src
[1]),
577 new(p
->mem_ctx
) ir_constant(-0.5f
));
579 case TEXENV_MODE_MODULATE_SUBTRACT_ATI
:
580 return sub(mul(src
[0], src
[2]), src
[1]);
582 case TEXENV_MODE_ADD_PRODUCTS_NV
:
583 return add(mul(src
[0], src
[1]), mul(src
[2], src
[3]));
585 case TEXENV_MODE_ADD_PRODUCTS_SIGNED_NV
:
586 return add(add(mul(src
[0], src
[1]), mul(src
[2], src
[3])),
587 new(p
->mem_ctx
) ir_constant(-0.5f
));
595 * Generate instructions for one texture unit's env/combiner mode.
598 emit_texenv(texenv_fragment_program
*p
, GLuint unit
)
600 const struct state_key
*key
= p
->state
;
601 GLboolean rgb_saturate
, alpha_saturate
;
602 GLuint rgb_shift
, alpha_shift
;
604 if (!key
->unit
[unit
].enabled
) {
605 return get_source(p
, TEXENV_SRC_PREVIOUS
, 0);
608 switch (key
->unit
[unit
].ModeRGB
) {
609 case TEXENV_MODE_DOT3_RGB_EXT
:
610 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
613 case TEXENV_MODE_DOT3_RGBA_EXT
:
618 rgb_shift
= key
->unit
[unit
].ScaleShiftRGB
;
619 alpha_shift
= key
->unit
[unit
].ScaleShiftA
;
623 /* If we'll do rgb/alpha shifting don't saturate in emit_combine().
624 * We don't want to clamp twice.
627 rgb_saturate
= GL_FALSE
; /* saturate after rgb shift */
628 else if (need_saturate(key
->unit
[unit
].ModeRGB
))
629 rgb_saturate
= GL_TRUE
;
631 rgb_saturate
= GL_FALSE
;
634 alpha_saturate
= GL_FALSE
; /* saturate after alpha shift */
635 else if (need_saturate(key
->unit
[unit
].ModeA
))
636 alpha_saturate
= GL_TRUE
;
638 alpha_saturate
= GL_FALSE
;
640 ir_variable
*temp_var
= p
->make_temp(glsl_type::vec4_type
, "texenv_combine");
641 ir_dereference
*deref
;
644 /* Emit the RGB and A combine ops
646 if (key
->unit
[unit
].ModeRGB
== key
->unit
[unit
].ModeA
&&
647 args_match(key
, unit
)) {
648 val
= emit_combine(p
, unit
,
649 key
->unit
[unit
].NumArgsRGB
,
650 key
->unit
[unit
].ModeRGB
,
651 key
->unit
[unit
].ArgsRGB
);
656 p
->emit(assign(temp_var
, val
));
658 else if (key
->unit
[unit
].ModeRGB
== TEXENV_MODE_DOT3_RGBA_EXT
||
659 key
->unit
[unit
].ModeRGB
== TEXENV_MODE_DOT3_RGBA
) {
660 ir_rvalue
*val
= emit_combine(p
, unit
,
661 key
->unit
[unit
].NumArgsRGB
,
662 key
->unit
[unit
].ModeRGB
,
663 key
->unit
[unit
].ArgsRGB
);
667 p
->emit(assign(temp_var
, val
));
670 /* Need to do something to stop from re-emitting identical
671 * argument calculations here:
673 val
= emit_combine(p
, unit
,
674 key
->unit
[unit
].NumArgsRGB
,
675 key
->unit
[unit
].ModeRGB
,
676 key
->unit
[unit
].ArgsRGB
);
677 val
= swizzle_xyz(smear(val
));
680 p
->emit(assign(temp_var
, val
, WRITEMASK_XYZ
));
682 val
= emit_combine(p
, unit
,
683 key
->unit
[unit
].NumArgsA
,
684 key
->unit
[unit
].ModeA
,
685 key
->unit
[unit
].ArgsA
);
686 val
= swizzle_w(smear(val
));
689 p
->emit(assign(temp_var
, val
, WRITEMASK_W
));
692 deref
= new(p
->mem_ctx
) ir_dereference_variable(temp_var
);
694 /* Deal with the final shift:
696 if (alpha_shift
|| rgb_shift
) {
699 if (rgb_shift
== alpha_shift
) {
700 shift
= new(p
->mem_ctx
) ir_constant((float)(1 << rgb_shift
));
703 ir_constant_data const_data
;
705 const_data
.f
[0] = float(1 << rgb_shift
);
706 const_data
.f
[1] = float(1 << rgb_shift
);
707 const_data
.f
[2] = float(1 << rgb_shift
);
708 const_data
.f
[3] = float(1 << alpha_shift
);
710 shift
= new(p
->mem_ctx
) ir_constant(glsl_type::vec4_type
,
714 return saturate(mul(deref
, shift
));
722 * Generate instruction for getting a texture source term.
724 static void load_texture( texenv_fragment_program
*p
, GLuint unit
)
726 ir_dereference
*deref
;
728 if (p
->src_texture
[unit
])
731 const GLuint texTarget
= p
->state
->unit
[unit
].source_index
;
734 if (!(p
->state
->inputs_available
& (VARYING_BIT_TEX0
<< unit
))) {
735 texcoord
= get_current_attrib(p
, VERT_ATTRIB_TEX0
+ unit
);
736 } else if (p
->texcoord_tex
[unit
]) {
737 texcoord
= new(p
->mem_ctx
) ir_dereference_variable(p
->texcoord_tex
[unit
]);
739 ir_variable
*tc_array
= p
->shader
->symbols
->get_variable("gl_TexCoord");
741 texcoord
= new(p
->mem_ctx
) ir_dereference_variable(tc_array
);
742 ir_rvalue
*index
= new(p
->mem_ctx
) ir_constant(unit
);
743 texcoord
= new(p
->mem_ctx
) ir_dereference_array(texcoord
, index
);
744 tc_array
->data
.max_array_access
= MAX2(tc_array
->data
.max_array_access
, (int)unit
);
747 if (!p
->state
->unit
[unit
].enabled
) {
748 p
->src_texture
[unit
] = p
->make_temp(glsl_type::vec4_type
,
750 p
->emit(p
->src_texture
[unit
]);
752 p
->emit(assign(p
->src_texture
[unit
], new(p
->mem_ctx
) ir_constant(0.0f
)));
756 const glsl_type
*sampler_type
= NULL
;
760 case TEXTURE_1D_INDEX
:
761 if (p
->state
->unit
[unit
].shadow
)
762 sampler_type
= glsl_type::sampler1DShadow_type
;
764 sampler_type
= glsl_type::sampler1D_type
;
767 case TEXTURE_1D_ARRAY_INDEX
:
768 if (p
->state
->unit
[unit
].shadow
)
769 sampler_type
= glsl_type::sampler1DArrayShadow_type
;
771 sampler_type
= glsl_type::sampler1DArray_type
;
774 case TEXTURE_2D_INDEX
:
775 if (p
->state
->unit
[unit
].shadow
)
776 sampler_type
= glsl_type::sampler2DShadow_type
;
778 sampler_type
= glsl_type::sampler2D_type
;
781 case TEXTURE_2D_ARRAY_INDEX
:
782 if (p
->state
->unit
[unit
].shadow
)
783 sampler_type
= glsl_type::sampler2DArrayShadow_type
;
785 sampler_type
= glsl_type::sampler2DArray_type
;
788 case TEXTURE_RECT_INDEX
:
789 if (p
->state
->unit
[unit
].shadow
)
790 sampler_type
= glsl_type::sampler2DRectShadow_type
;
792 sampler_type
= glsl_type::sampler2DRect_type
;
795 case TEXTURE_3D_INDEX
:
796 assert(!p
->state
->unit
[unit
].shadow
);
797 sampler_type
= glsl_type::sampler3D_type
;
800 case TEXTURE_CUBE_INDEX
:
801 if (p
->state
->unit
[unit
].shadow
)
802 sampler_type
= glsl_type::samplerCubeShadow_type
;
804 sampler_type
= glsl_type::samplerCube_type
;
807 case TEXTURE_EXTERNAL_INDEX
:
808 assert(!p
->state
->unit
[unit
].shadow
);
809 sampler_type
= glsl_type::samplerExternalOES_type
;
814 p
->src_texture
[unit
] = p
->make_temp(glsl_type::vec4_type
,
817 ir_texture
*tex
= new(p
->mem_ctx
) ir_texture(ir_tex
);
820 char *sampler_name
= ralloc_asprintf(p
->mem_ctx
, "sampler_%d", unit
);
821 ir_variable
*sampler
= new(p
->mem_ctx
) ir_variable(sampler_type
,
824 p
->top_instructions
->push_head(sampler
);
826 /* Set the texture unit for this sampler in the same way that
827 * layout(binding=X) would.
829 sampler
->data
.explicit_binding
= true;
830 sampler
->data
.binding
= unit
;
832 deref
= new(p
->mem_ctx
) ir_dereference_variable(sampler
);
833 tex
->set_sampler(deref
, glsl_type::vec4_type
);
835 tex
->coordinate
= new(p
->mem_ctx
) ir_swizzle(texcoord
, 0, 1, 2, 3, coords
);
837 if (p
->state
->unit
[unit
].shadow
) {
838 texcoord
= texcoord
->clone(p
->mem_ctx
, NULL
);
839 tex
->shadow_comparator
= new(p
->mem_ctx
) ir_swizzle(texcoord
,
845 texcoord
= texcoord
->clone(p
->mem_ctx
, NULL
);
846 tex
->projector
= swizzle_w(texcoord
);
848 p
->emit(assign(p
->src_texture
[unit
], tex
));
852 load_texenv_source(texenv_fragment_program
*p
,
853 GLuint src
, GLuint unit
)
856 case TEXENV_SRC_TEXTURE
:
857 load_texture(p
, unit
);
860 case TEXENV_SRC_TEXTURE0
:
861 case TEXENV_SRC_TEXTURE1
:
862 case TEXENV_SRC_TEXTURE2
:
863 case TEXENV_SRC_TEXTURE3
:
864 case TEXENV_SRC_TEXTURE4
:
865 case TEXENV_SRC_TEXTURE5
:
866 case TEXENV_SRC_TEXTURE6
:
867 case TEXENV_SRC_TEXTURE7
:
868 load_texture(p
, src
- TEXENV_SRC_TEXTURE0
);
872 /* not a texture src - do nothing */
879 * Generate instructions for loading all texture source terms.
882 load_texunit_sources( texenv_fragment_program
*p
, GLuint unit
)
884 const struct state_key
*key
= p
->state
;
887 for (i
= 0; i
< key
->unit
[unit
].NumArgsRGB
; i
++) {
888 load_texenv_source( p
, key
->unit
[unit
].ArgsRGB
[i
].Source
, unit
);
891 for (i
= 0; i
< key
->unit
[unit
].NumArgsA
; i
++) {
892 load_texenv_source( p
, key
->unit
[unit
].ArgsA
[i
].Source
, unit
);
899 * Applies the fog calculations.
901 * This is basically like the ARB_fragment_prorgam fog options. Note
902 * that ffvertex_prog.c produces fogcoord for us when
903 * GL_FOG_COORDINATE_EXT is set to GL_FRAGMENT_DEPTH_EXT.
906 emit_fog_instructions(texenv_fragment_program
*p
,
907 ir_rvalue
*fragcolor
)
909 struct state_key
*key
= p
->state
;
911 ir_variable
*params
, *oparams
;
912 ir_variable
*fogcoord
;
914 /* Temporary storage for the whole fog result. Fog calculations
915 * only affect rgb so we're hanging on to the .a value of fragcolor
918 ir_variable
*fog_result
= p
->make_temp(glsl_type::vec4_type
, "fog_result");
919 p
->emit(assign(fog_result
, fragcolor
));
921 fragcolor
= swizzle_xyz(fog_result
);
923 oparams
= p
->shader
->symbols
->get_variable("gl_FogParamsOptimizedMESA");
925 fogcoord
= p
->shader
->symbols
->get_variable("gl_FogFragCoord");
927 params
= p
->shader
->symbols
->get_variable("gl_Fog");
929 f
= new(p
->mem_ctx
) ir_dereference_variable(fogcoord
);
931 ir_variable
*f_var
= p
->make_temp(glsl_type::float_type
, "fog_factor");
933 switch (key
->fog_mode
) {
935 /* f = (end - z) / (end - start)
937 * gl_MesaFogParamsOptimized gives us (-1 / (end - start)) and
938 * (end / (end - start)) so we can generate a single MAD.
940 f
= add(mul(f
, swizzle_x(oparams
)), swizzle_y(oparams
));
943 /* f = e^(-(density * fogcoord))
945 * gl_MesaFogParamsOptimized gives us density/ln(2) so we can
946 * use EXP2 which is generally the native instruction without
947 * having to do any further math on the fog density uniform.
949 f
= mul(f
, swizzle_z(oparams
));
950 f
= new(p
->mem_ctx
) ir_expression(ir_unop_neg
, f
);
951 f
= new(p
->mem_ctx
) ir_expression(ir_unop_exp2
, f
);
954 /* f = e^(-(density * fogcoord)^2)
956 * gl_MesaFogParamsOptimized gives us density/sqrt(ln(2)) so we
957 * can do this like FOG_EXP but with a squaring after the
958 * multiply by density.
960 ir_variable
*temp_var
= p
->make_temp(glsl_type::float_type
, "fog_temp");
961 p
->emit(assign(temp_var
, mul(f
, swizzle_w(oparams
))));
963 f
= mul(temp_var
, temp_var
);
964 f
= new(p
->mem_ctx
) ir_expression(ir_unop_neg
, f
);
965 f
= new(p
->mem_ctx
) ir_expression(ir_unop_exp2
, f
);
969 p
->emit(assign(f_var
, saturate(f
)));
971 f
= sub(new(p
->mem_ctx
) ir_constant(1.0f
), f_var
);
972 temp
= new(p
->mem_ctx
) ir_dereference_variable(params
);
973 temp
= new(p
->mem_ctx
) ir_dereference_record(temp
, "color");
974 temp
= mul(swizzle_xyz(temp
), f
);
976 p
->emit(assign(fog_result
, add(temp
, mul(fragcolor
, f_var
)), WRITEMASK_XYZ
));
978 return new(p
->mem_ctx
) ir_dereference_variable(fog_result
);
982 emit_instructions(texenv_fragment_program
*p
)
984 struct state_key
*key
= p
->state
;
987 if (key
->nr_enabled_units
) {
988 /* First pass - to support texture_env_crossbar, first identify
989 * all referenced texture sources and emit texld instructions
992 for (unit
= 0; unit
< key
->nr_enabled_units
; unit
++)
993 if (key
->unit
[unit
].enabled
) {
994 load_texunit_sources(p
, unit
);
997 /* Second pass - emit combine instructions to build final color:
999 for (unit
= 0; unit
< key
->nr_enabled_units
; unit
++) {
1000 if (key
->unit
[unit
].enabled
) {
1001 p
->src_previous
= emit_texenv(p
, unit
);
1006 ir_rvalue
*cf
= get_source(p
, TEXENV_SRC_PREVIOUS
, 0);
1008 if (key
->separate_specular
) {
1009 ir_variable
*spec_result
= p
->make_temp(glsl_type::vec4_type
,
1011 p
->emit(assign(spec_result
, cf
));
1013 ir_rvalue
*secondary
;
1014 if (p
->state
->inputs_available
& VARYING_BIT_COL1
) {
1016 p
->shader
->symbols
->get_variable("gl_SecondaryColor");
1018 secondary
= swizzle_xyz(var
);
1020 secondary
= swizzle_xyz(get_current_attrib(p
, VERT_ATTRIB_COLOR1
));
1023 p
->emit(assign(spec_result
, add(swizzle_xyz(spec_result
), secondary
),
1026 cf
= new(p
->mem_ctx
) ir_dereference_variable(spec_result
);
1029 if (key
->fog_mode
) {
1030 cf
= emit_fog_instructions(p
, cf
);
1033 ir_variable
*frag_color
= p
->shader
->symbols
->get_variable("gl_FragColor");
1035 p
->emit(assign(frag_color
, cf
));
1039 * Generate a new fragment program which implements the context's
1040 * current texture env/combine mode.
1042 static struct gl_shader_program
*
1043 create_new_program(struct gl_context
*ctx
, struct state_key
*key
)
1045 texenv_fragment_program p
;
1047 _mesa_glsl_parse_state
*state
;
1049 p
.mem_ctx
= ralloc_context(NULL
);
1050 p
.shader
= _mesa_new_shader(0, MESA_SHADER_FRAGMENT
);
1052 p
.shader
->SourceChecksum
= 0xf18ed; /* fixed */
1054 p
.shader
->ir
= new(p
.shader
) exec_list
;
1055 state
= new(p
.shader
) _mesa_glsl_parse_state(ctx
, MESA_SHADER_FRAGMENT
,
1057 p
.shader
->symbols
= state
->symbols
;
1058 p
.top_instructions
= p
.shader
->ir
;
1059 p
.instructions
= p
.shader
->ir
;
1061 p
.shader_program
= _mesa_new_shader_program(0);
1063 /* Tell the linker to ignore the fact that we're building a
1064 * separate shader, in case we're in a GLES2 context that would
1065 * normally reject that. The real problem is that we're building a
1066 * fixed function program in a GLES2 context at all, but that's a
1067 * big mess to clean up.
1069 p
.shader_program
->SeparateShader
= GL_TRUE
;
1071 /* The legacy GLSL shadow functions follow the depth texture
1072 * mode and return vec4. The GLSL 1.30 shadow functions return float and
1073 * ignore the depth texture mode. That's a shader and state dependency
1074 * that's difficult to deal with. st/mesa uses a simple but not
1075 * completely correct solution: if the shader declares GLSL >= 1.30 and
1076 * the depth texture mode is GL_ALPHA (000X), it sets the XXXX swizzle
1077 * instead. Thus, the GLSL 1.30 shadow function will get the result in .x
1078 * and legacy shadow functions will get it in .w as expected.
1079 * For the fixed-function fragment shader, use 120 to get correct behavior
1082 state
->language_version
= 120;
1084 state
->es_shader
= false;
1085 if (_mesa_is_gles(ctx
) && ctx
->Extensions
.OES_EGL_image_external
)
1086 state
->OES_EGL_image_external_enable
= true;
1087 _mesa_glsl_initialize_types(state
);
1088 _mesa_glsl_initialize_variables(p
.instructions
, state
);
1090 for (unit
= 0; unit
< ctx
->Const
.MaxTextureUnits
; unit
++) {
1091 p
.src_texture
[unit
] = NULL
;
1092 p
.texcoord_tex
[unit
] = NULL
;
1095 p
.src_previous
= NULL
;
1097 ir_function
*main_f
= new(p
.mem_ctx
) ir_function("main");
1099 state
->symbols
->add_function(main_f
);
1101 ir_function_signature
*main_sig
=
1102 new(p
.mem_ctx
) ir_function_signature(glsl_type::void_type
);
1103 main_sig
->is_defined
= true;
1104 main_f
->add_signature(main_sig
);
1106 p
.instructions
= &main_sig
->body
;
1107 if (key
->num_draw_buffers
)
1108 emit_instructions(&p
);
1110 validate_ir_tree(p
.shader
->ir
);
1112 const struct gl_shader_compiler_options
*options
=
1113 &ctx
->Const
.ShaderCompilerOptions
[MESA_SHADER_FRAGMENT
];
1115 /* Conservative approach: Don't optimize here, the linker does it too. */
1116 if (!ctx
->Const
.GLSLOptimizeConservatively
) {
1117 while (do_common_optimization(p
.shader
->ir
, false, false, options
,
1118 ctx
->Const
.NativeIntegers
))
1122 reparent_ir(p
.shader
->ir
, p
.shader
->ir
);
1124 p
.shader
->CompileStatus
= COMPILE_SUCCESS
;
1125 p
.shader
->Version
= state
->language_version
;
1126 p
.shader_program
->Shaders
=
1127 (gl_shader
**)malloc(sizeof(*p
.shader_program
->Shaders
));
1128 p
.shader_program
->Shaders
[0] = p
.shader
;
1129 p
.shader_program
->NumShaders
= 1;
1131 _mesa_glsl_link_shader(ctx
, p
.shader_program
);
1133 if (!p
.shader_program
->data
->LinkStatus
)
1134 _mesa_problem(ctx
, "Failed to link fixed function fragment shader: %s\n",
1135 p
.shader_program
->data
->InfoLog
);
1137 ralloc_free(p
.mem_ctx
);
1138 return p
.shader_program
;
1144 * Return a fragment program which implements the current
1145 * fixed-function texture, fog and color-sum operations.
1147 struct gl_shader_program
*
1148 _mesa_get_fixed_func_fragment_program(struct gl_context
*ctx
)
1150 struct gl_shader_program
*shader_program
;
1151 struct state_key key
;
1154 keySize
= make_state_key(ctx
, &key
);
1156 shader_program
= (struct gl_shader_program
*)
1157 _mesa_search_program_cache(ctx
->FragmentProgram
.Cache
,
1160 if (!shader_program
) {
1161 shader_program
= create_new_program(ctx
, &key
);
1163 _mesa_shader_cache_insert(ctx
, ctx
->FragmentProgram
.Cache
,
1164 &key
, keySize
, shader_program
);
1167 return shader_program
;