1 /*
2 * Copyright © 2010 Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24 #include "ir.h"
25 #include "glsl_parser_extras.h"
26 #include "glsl_symbol_table.h"
27 #include "main/core.h"
28 #include "main/uniforms.h"
29 #include "program/prog_parameter.h"
30 #include "program/prog_statevars.h"
31 #include "program/prog_instruction.h"
32
33 static void generate_ARB_draw_buffers_variables(exec_list *,
34 struct _mesa_glsl_parse_state *,
35 bool, _mesa_glsl_parser_targets);
36
37 static void
38 generate_ARB_draw_instanced_variables(exec_list *,
39 struct _mesa_glsl_parse_state *,
40 bool, _mesa_glsl_parser_targets);
41
42 struct builtin_variable {
43 enum ir_variable_mode mode;
44 int slot;
45 const char *type;
46 const char *name;
47 };
48
49 static const builtin_variable builtin_core_vs_variables[] = {
50 { ir_var_out, VERT_RESULT_HPOS, "vec4", "gl_Position" },
51 { ir_var_out, VERT_RESULT_PSIZ, "float", "gl_PointSize" },
52 };
53
54 static const builtin_variable builtin_core_fs_variables[] = {
55 { ir_var_in, FRAG_ATTRIB_WPOS, "vec4", "gl_FragCoord" },
56 { ir_var_in, FRAG_ATTRIB_FACE, "bool", "gl_FrontFacing" },
57 { ir_var_out, FRAG_RESULT_COLOR, "vec4", "gl_FragColor" },
58 };
59
60 static const builtin_variable builtin_100ES_fs_variables[] = {
61 { ir_var_in, FRAG_ATTRIB_PNTC, "vec2", "gl_PointCoord" },
62 };
63
64 static const builtin_variable builtin_110_fs_variables[] = {
65 { ir_var_out, FRAG_RESULT_DEPTH, "float", "gl_FragDepth" },
66 };
67
68 static const builtin_variable builtin_110_deprecated_fs_variables[] = {
69 { ir_var_in, FRAG_ATTRIB_COL0, "vec4", "gl_Color" },
70 { ir_var_in, FRAG_ATTRIB_COL1, "vec4", "gl_SecondaryColor" },
71 { ir_var_in, FRAG_ATTRIB_FOGC, "float", "gl_FogFragCoord" },
72 };
73
74 static const builtin_variable builtin_110_deprecated_vs_variables[] = {
75 { ir_var_in, VERT_ATTRIB_POS, "vec4", "gl_Vertex" },
76 { ir_var_in, VERT_ATTRIB_NORMAL, "vec3", "gl_Normal" },
77 { ir_var_in, VERT_ATTRIB_COLOR0, "vec4", "gl_Color" },
78 { ir_var_in, VERT_ATTRIB_COLOR1, "vec4", "gl_SecondaryColor" },
79 { ir_var_in, VERT_ATTRIB_TEX0, "vec4", "gl_MultiTexCoord0" },
80 { ir_var_in, VERT_ATTRIB_TEX1, "vec4", "gl_MultiTexCoord1" },
81 { ir_var_in, VERT_ATTRIB_TEX2, "vec4", "gl_MultiTexCoord2" },
82 { ir_var_in, VERT_ATTRIB_TEX3, "vec4", "gl_MultiTexCoord3" },
83 { ir_var_in, VERT_ATTRIB_TEX4, "vec4", "gl_MultiTexCoord4" },
84 { ir_var_in, VERT_ATTRIB_TEX5, "vec4", "gl_MultiTexCoord5" },
85 { ir_var_in, VERT_ATTRIB_TEX6, "vec4", "gl_MultiTexCoord6" },
86 { ir_var_in, VERT_ATTRIB_TEX7, "vec4", "gl_MultiTexCoord7" },
87 { ir_var_in, VERT_ATTRIB_FOG, "float", "gl_FogCoord" },
88 { ir_var_out, VERT_RESULT_CLIP_VERTEX, "vec4", "gl_ClipVertex" },
89 { ir_var_out, VERT_RESULT_COL0, "vec4", "gl_FrontColor" },
90 { ir_var_out, VERT_RESULT_BFC0, "vec4", "gl_BackColor" },
91 { ir_var_out, VERT_RESULT_COL1, "vec4", "gl_FrontSecondaryColor" },
92 { ir_var_out, VERT_RESULT_BFC1, "vec4", "gl_BackSecondaryColor" },
93 { ir_var_out, VERT_RESULT_FOGC, "float", "gl_FogFragCoord" },
94 };
95
96 static const builtin_variable builtin_120_fs_variables[] = {
97 { ir_var_in, FRAG_ATTRIB_PNTC, "vec2", "gl_PointCoord" },
98 };
99
100 static const builtin_variable builtin_130_vs_variables[] = {
101 { ir_var_system_value, SYSTEM_VALUE_VERTEX_ID, "int", "gl_VertexID" },
102 };
103
104 static const builtin_variable builtin_110_deprecated_uniforms[] = {
105 { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrix" },
106 { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrix" },
107 { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrix" },
108 { ir_var_uniform, -1, "mat3", "gl_NormalMatrix" },
109 { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverse" },
110 { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverse" },
111 { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverse" },
112 { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixTranspose" },
113 { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixTranspose" },
114 { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixTranspose" },
115 { ir_var_uniform, -1, "mat4", "gl_ModelViewMatrixInverseTranspose" },
116 { ir_var_uniform, -1, "mat4", "gl_ProjectionMatrixInverseTranspose" },
117 { ir_var_uniform, -1, "mat4", "gl_ModelViewProjectionMatrixInverseTranspose" },
118 { ir_var_uniform, -1, "float", "gl_NormalScale" },
119 { ir_var_uniform, -1, "gl_LightModelParameters", "gl_LightModel"},
120
121 /* Mesa-internal ATI_envmap_bumpmap state. */
122 { ir_var_uniform, -1, "vec2", "gl_BumpRotMatrix0MESA"},
123 { ir_var_uniform, -1, "vec2", "gl_BumpRotMatrix1MESA"},
124 { ir_var_uniform, -1, "vec4", "gl_FogParamsOptimizedMESA"},
125 };
126
127 static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
128 {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
129 {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
130 {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
131 };
132
133 static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
134 {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
135 };
136
137 static struct gl_builtin_uniform_element gl_Point_elements[] = {
138 {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
139 {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
140 {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
141 {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
142 {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
143 {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
144 {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
145 };
146
147 static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
148 {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
149 {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
150 {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
151 {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
152 {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
153 };
154
155 static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
156 {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
157 {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
158 {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
159 {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
160 {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
161 };
162
163 static struct gl_builtin_uniform_element gl_LightSource_elements[] = {
164 {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
165 {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
166 {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
167 {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
168 {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
169 {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
170 MAKE_SWIZZLE4(SWIZZLE_X,
171 SWIZZLE_Y,
172 SWIZZLE_Z,
173 SWIZZLE_Z)},
174 {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
175 {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
176 {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
177 {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
178 {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
179 {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
180 };
181
182 static struct gl_builtin_uniform_element gl_LightModel_elements[] = {
183 {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
184 };
185
186 static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
187 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
188 };
189
190 static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
191 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
192 };
193
194 static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
195 {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
196 {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
197 {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
198 };
199
200 static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
201 {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
202 {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
203 {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
204 };
205
206 static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
207 {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
208 };
209
210 static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
211 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
212 };
213
214 static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
215 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
216 };
217
218 static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
219 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
220 };
221
222 static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
223 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
224 };
225
226 static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
227 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
228 };
229
230 static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
231 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
232 };
233
234 static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
235 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
236 };
237
238 static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
239 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
240 };
241
242 static struct gl_builtin_uniform_element gl_Fog_elements[] = {
243 {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
244 {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
245 {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
246 {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
247 {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
248 };
249
250 static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
251 {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
252 };
253
254 static struct gl_builtin_uniform_element gl_BumpRotMatrix0MESA_elements[] = {
255 {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},
256 };
257
258 static struct gl_builtin_uniform_element gl_BumpRotMatrix1MESA_elements[] = {
259 {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},
260 };
261
262 static struct gl_builtin_uniform_element gl_FogParamsOptimizedMESA_elements[] = {
263 {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},
264 };
265
266 static struct gl_builtin_uniform_element gl_CurrentAttribVertMESA_elements[] = {
267 {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB, 0}, SWIZZLE_XYZW},
268 };
269
270 static struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements[] = {
271 {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW},
272 };
273
274 #define MATRIX(name, statevar, modifier) \
275 static struct gl_builtin_uniform_element name ## _elements[] = { \
276 { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW }, \
277 { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW }, \
278 { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW }, \
279 { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW }, \
280 }
281
282 MATRIX(gl_ModelViewMatrix,
283 STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
284 MATRIX(gl_ModelViewMatrixInverse,
285 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
286 MATRIX(gl_ModelViewMatrixTranspose,
287 STATE_MODELVIEW_MATRIX, 0);
288 MATRIX(gl_ModelViewMatrixInverseTranspose,
289 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
290
291 MATRIX(gl_ProjectionMatrix,
292 STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
293 MATRIX(gl_ProjectionMatrixInverse,
294 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
295 MATRIX(gl_ProjectionMatrixTranspose,
296 STATE_PROJECTION_MATRIX, 0);
297 MATRIX(gl_ProjectionMatrixInverseTranspose,
298 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
299
300 MATRIX(gl_ModelViewProjectionMatrix,
301 STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
302 MATRIX(gl_ModelViewProjectionMatrixInverse,
303 STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
304 MATRIX(gl_ModelViewProjectionMatrixTranspose,
305 STATE_MVP_MATRIX, 0);
306 MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
307 STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
308
309 MATRIX(gl_TextureMatrix,
310 STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
311 MATRIX(gl_TextureMatrixInverse,
312 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
313 MATRIX(gl_TextureMatrixTranspose,
314 STATE_TEXTURE_MATRIX, 0);
315 MATRIX(gl_TextureMatrixInverseTranspose,
316 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
317
318 static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
319 { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
320 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
321 { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
322 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
323 { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
324 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) },
325 };
326
327 #undef MATRIX
328
329 #define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}
330
331 const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
332 STATEVAR(gl_DepthRange),
333 STATEVAR(gl_ClipPlane),
334 STATEVAR(gl_Point),
335 STATEVAR(gl_FrontMaterial),
336 STATEVAR(gl_BackMaterial),
337 STATEVAR(gl_LightSource),
338 STATEVAR(gl_LightModel),
339 STATEVAR(gl_FrontLightModelProduct),
340 STATEVAR(gl_BackLightModelProduct),
341 STATEVAR(gl_FrontLightProduct),
342 STATEVAR(gl_BackLightProduct),
343 STATEVAR(gl_TextureEnvColor),
344 STATEVAR(gl_EyePlaneS),
345 STATEVAR(gl_EyePlaneT),
346 STATEVAR(gl_EyePlaneR),
347 STATEVAR(gl_EyePlaneQ),
348 STATEVAR(gl_ObjectPlaneS),
349 STATEVAR(gl_ObjectPlaneT),
350 STATEVAR(gl_ObjectPlaneR),
351 STATEVAR(gl_ObjectPlaneQ),
352 STATEVAR(gl_Fog),
353
354 STATEVAR(gl_ModelViewMatrix),
355 STATEVAR(gl_ModelViewMatrixInverse),
356 STATEVAR(gl_ModelViewMatrixTranspose),
357 STATEVAR(gl_ModelViewMatrixInverseTranspose),
358
359 STATEVAR(gl_ProjectionMatrix),
360 STATEVAR(gl_ProjectionMatrixInverse),
361 STATEVAR(gl_ProjectionMatrixTranspose),
362 STATEVAR(gl_ProjectionMatrixInverseTranspose),
363
364 STATEVAR(gl_ModelViewProjectionMatrix),
365 STATEVAR(gl_ModelViewProjectionMatrixInverse),
366 STATEVAR(gl_ModelViewProjectionMatrixTranspose),
367 STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),
368
369 STATEVAR(gl_TextureMatrix),
370 STATEVAR(gl_TextureMatrixInverse),
371 STATEVAR(gl_TextureMatrixTranspose),
372 STATEVAR(gl_TextureMatrixInverseTranspose),
373
374 STATEVAR(gl_NormalMatrix),
375 STATEVAR(gl_NormalScale),
376
377 STATEVAR(gl_BumpRotMatrix0MESA),
378 STATEVAR(gl_BumpRotMatrix1MESA),
379 STATEVAR(gl_FogParamsOptimizedMESA),
380 STATEVAR(gl_CurrentAttribVertMESA),
381 STATEVAR(gl_CurrentAttribFragMESA),
382
383 {NULL, NULL, 0}
384 };
385
386 static ir_variable *
add_variable(exec_list * instructions,glsl_symbol_table * symtab,const char * name,const glsl_type * type,enum ir_variable_mode mode,int slot)387 add_variable(exec_list *instructions, glsl_symbol_table *symtab,
388 const char *name, const glsl_type *type,
389 enum ir_variable_mode mode, int slot)
390 {
391 ir_variable *var = new(symtab) ir_variable(type, name, mode);
392
393 switch (var->mode) {
394 case ir_var_auto:
395 case ir_var_in:
396 case ir_var_const_in:
397 case ir_var_uniform:
398 case ir_var_system_value:
399 var->read_only = true;
400 break;
401 case ir_var_inout:
402 case ir_var_out:
403 break;
404 default:
405 assert(0);
406 break;
407 }
408
409 var->location = slot;
410 var->explicit_location = (slot >= 0);
411 var->explicit_index = 0;
412
413 /* Once the variable is created an initialized, add it to the symbol table
414 * and add the declaration to the IR stream.
415 */
416 instructions->push_tail(var);
417
418 symtab->add_variable(var);
419 return var;
420 }
421
422 static ir_variable *
add_uniform(exec_list * instructions,glsl_symbol_table * symtab,const char * name,const glsl_type * type)423 add_uniform(exec_list *instructions, glsl_symbol_table *symtab,
424 const char *name, const glsl_type *type)
425 {
426 ir_variable *const uni =
427 add_variable(instructions, symtab, name, type, ir_var_uniform, -1);
428
429 unsigned i;
430 for (i = 0; _mesa_builtin_uniform_desc[i].name != NULL; i++) {
431 if (strcmp(_mesa_builtin_uniform_desc[i].name, name) == 0) {
432 break;
433 }
434 }
435
436 assert(_mesa_builtin_uniform_desc[i].name != NULL);
437 const struct gl_builtin_uniform_desc* const statevar =
438 &_mesa_builtin_uniform_desc[i];
439
440 const unsigned array_count = type->is_array() ? type->length : 1;
441 uni->num_state_slots = array_count * statevar->num_elements;
442
443 ir_state_slot *slots =
444 ralloc_array(uni, ir_state_slot, uni->num_state_slots);
445
446 uni->state_slots = slots;
447
448 for (unsigned a = 0; a < array_count; a++) {
449 for (unsigned j = 0; j < statevar->num_elements; j++) {
450 struct gl_builtin_uniform_element *element = &statevar->elements[j];
451
452 memcpy(slots->tokens, element->tokens, sizeof(element->tokens));
453 if (type->is_array()) {
454 if (strcmp(name, "gl_CurrentAttribVertMESA") == 0 ||
455 strcmp(name, "gl_CurrentAttribFragMESA") == 0) {
456 slots->tokens[2] = a;
457 } else {
458 slots->tokens[1] = a;
459 }
460 }
461
462 slots->swizzle = element->swizzle;
463 slots++;
464 }
465 }
466
467 return uni;
468 }
469
470 static void
add_builtin_variable(exec_list * instructions,glsl_symbol_table * symtab,const builtin_variable * proto)471 add_builtin_variable(exec_list *instructions, glsl_symbol_table *symtab,
472 const builtin_variable *proto)
473 {
474 /* Create a new variable declaration from the description supplied by
475 * the caller.
476 */
477 const glsl_type *const type = symtab->get_type(proto->type);
478
479 assert(type != NULL);
480
481 if (proto->mode == ir_var_uniform) {
482 add_uniform(instructions, symtab, proto->name, type);
483 } else {
484 add_variable(instructions, symtab, proto->name, type, proto->mode,
485 proto->slot);
486 }
487 }
488
489 static ir_variable *
add_builtin_constant(exec_list * instructions,glsl_symbol_table * symtab,const char * name,int value)490 add_builtin_constant(exec_list *instructions, glsl_symbol_table *symtab,
491 const char *name, int value)
492 {
493 ir_variable *const var = add_variable(instructions, symtab,
494 name, glsl_type::int_type,
495 ir_var_auto, -1);
496 var->constant_value = new(var) ir_constant(value);
497 var->constant_initializer = new(var) ir_constant(value);
498 var->has_initializer = true;
499 return var;
500 }
501
502 /* Several constants in GLSL ES have different names than normal desktop GLSL.
503 * Therefore, this function should only be called on the ES path.
504 */
505 static void
generate_100ES_uniforms(exec_list * instructions,struct _mesa_glsl_parse_state * state)506 generate_100ES_uniforms(exec_list *instructions,
507 struct _mesa_glsl_parse_state *state)
508 {
509 glsl_symbol_table *const symtab = state->symbols;
510
511 add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
512 state->Const.MaxVertexAttribs);
513 add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformVectors",
514 state->Const.MaxVertexUniformComponents);
515 add_builtin_constant(instructions, symtab, "gl_MaxVaryingVectors",
516 state->Const.MaxVaryingFloats / 4);
517 add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
518 state->Const.MaxVertexTextureImageUnits);
519 add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
520 state->Const.MaxCombinedTextureImageUnits);
521 add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
522 state->Const.MaxTextureImageUnits);
523 add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformVectors",
524 state->Const.MaxFragmentUniformComponents);
525
526 add_uniform(instructions, symtab, "gl_DepthRange",
527 state->symbols->get_type("gl_DepthRangeParameters"));
528 }
529
530 static void
generate_110_uniforms(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)531 generate_110_uniforms(exec_list *instructions,
532 struct _mesa_glsl_parse_state *state,
533 bool add_deprecated)
534 {
535 glsl_symbol_table *const symtab = state->symbols;
536
537 if (add_deprecated) {
538 for (unsigned i = 0
539 ; i < Elements(builtin_110_deprecated_uniforms)
540 ; i++) {
541 add_builtin_variable(instructions, symtab,
542 & builtin_110_deprecated_uniforms[i]);
543 }
544 }
545
546 if (add_deprecated) {
547 add_builtin_constant(instructions, symtab, "gl_MaxLights",
548 state->Const.MaxLights);
549 add_builtin_constant(instructions, symtab, "gl_MaxClipPlanes",
550 state->Const.MaxClipPlanes);
551 add_builtin_constant(instructions, symtab, "gl_MaxTextureUnits",
552 state->Const.MaxTextureUnits);
553 add_builtin_constant(instructions, symtab, "gl_MaxTextureCoords",
554 state->Const.MaxTextureCoords);
555 }
556 add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
557 state->Const.MaxVertexAttribs);
558 add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformComponents",
559 state->Const.MaxVertexUniformComponents);
560 add_builtin_constant(instructions, symtab, "gl_MaxVaryingFloats",
561 state->Const.MaxVaryingFloats);
562 add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
563 state->Const.MaxVertexTextureImageUnits);
564 add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
565 state->Const.MaxCombinedTextureImageUnits);
566 add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
567 state->Const.MaxTextureImageUnits);
568 add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformComponents",
569 state->Const.MaxFragmentUniformComponents);
570
571 if (add_deprecated) {
572 const glsl_type *const mat4_array_type =
573 glsl_type::get_array_instance(glsl_type::mat4_type,
574 state->Const.MaxTextureCoords);
575
576 add_uniform(instructions, symtab, "gl_TextureMatrix", mat4_array_type);
577 add_uniform(instructions, symtab, "gl_TextureMatrixInverse", mat4_array_type);
578 add_uniform(instructions, symtab, "gl_TextureMatrixTranspose", mat4_array_type);
579 add_uniform(instructions, symtab, "gl_TextureMatrixInverseTranspose", mat4_array_type);
580 }
581
582 add_uniform(instructions, symtab, "gl_DepthRange",
583 symtab->get_type("gl_DepthRangeParameters"));
584
585 if (add_deprecated) {
586 add_uniform(instructions, symtab, "gl_ClipPlane",
587 glsl_type::get_array_instance(glsl_type::vec4_type,
588 state->Const.MaxClipPlanes));
589 add_uniform(instructions, symtab, "gl_Point",
590 symtab->get_type("gl_PointParameters"));
591
592 const glsl_type *const material_parameters_type =
593 symtab->get_type("gl_MaterialParameters");
594 add_uniform(instructions, symtab, "gl_FrontMaterial", material_parameters_type);
595 add_uniform(instructions, symtab, "gl_BackMaterial", material_parameters_type);
596
597 const glsl_type *const light_source_array_type =
598 glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), state->Const.MaxLights);
599
600 add_uniform(instructions, symtab, "gl_LightSource", light_source_array_type);
601
602 const glsl_type *const light_model_products_type =
603 symtab->get_type("gl_LightModelProducts");
604 add_uniform(instructions, symtab, "gl_FrontLightModelProduct",
605 light_model_products_type);
606 add_uniform(instructions, symtab, "gl_BackLightModelProduct",
607 light_model_products_type);
608
609 const glsl_type *const light_products_type =
610 glsl_type::get_array_instance(symtab->get_type("gl_LightProducts"),
611 state->Const.MaxLights);
612 add_uniform(instructions, symtab, "gl_FrontLightProduct", light_products_type);
613 add_uniform(instructions, symtab, "gl_BackLightProduct", light_products_type);
614
615 add_uniform(instructions, symtab, "gl_TextureEnvColor",
616 glsl_type::get_array_instance(glsl_type::vec4_type,
617 state->Const.MaxTextureUnits));
618
619 const glsl_type *const texcoords_vec4 =
620 glsl_type::get_array_instance(glsl_type::vec4_type,
621 state->Const.MaxTextureCoords);
622 add_uniform(instructions, symtab, "gl_EyePlaneS", texcoords_vec4);
623 add_uniform(instructions, symtab, "gl_EyePlaneT", texcoords_vec4);
624 add_uniform(instructions, symtab, "gl_EyePlaneR", texcoords_vec4);
625 add_uniform(instructions, symtab, "gl_EyePlaneQ", texcoords_vec4);
626 add_uniform(instructions, symtab, "gl_ObjectPlaneS", texcoords_vec4);
627 add_uniform(instructions, symtab, "gl_ObjectPlaneT", texcoords_vec4);
628 add_uniform(instructions, symtab, "gl_ObjectPlaneR", texcoords_vec4);
629 add_uniform(instructions, symtab, "gl_ObjectPlaneQ", texcoords_vec4);
630
631 add_uniform(instructions, symtab, "gl_Fog",
632 symtab->get_type("gl_FogParameters"));
633 }
634
635 /* Mesa-internal current attrib state */
636 const glsl_type *const vert_attribs =
637 glsl_type::get_array_instance(glsl_type::vec4_type, VERT_ATTRIB_MAX);
638 add_uniform(instructions, symtab, "gl_CurrentAttribVertMESA", vert_attribs);
639 const glsl_type *const frag_attribs =
640 glsl_type::get_array_instance(glsl_type::vec4_type, FRAG_ATTRIB_MAX);
641 add_uniform(instructions, symtab, "gl_CurrentAttribFragMESA", frag_attribs);
642 }
643
644 /* This function should only be called for ES, not desktop GL. */
645 static void
generate_100ES_vs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)646 generate_100ES_vs_variables(exec_list *instructions,
647 struct _mesa_glsl_parse_state *state)
648 {
649 for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
650 add_builtin_variable(instructions, state->symbols,
651 & builtin_core_vs_variables[i]);
652 }
653
654 generate_100ES_uniforms(instructions, state);
655
656 generate_ARB_draw_buffers_variables(instructions, state, false,
657 vertex_shader);
658 }
659
660
661 static void
generate_110_vs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)662 generate_110_vs_variables(exec_list *instructions,
663 struct _mesa_glsl_parse_state *state,
664 bool add_deprecated)
665 {
666 for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
667 add_builtin_variable(instructions, state->symbols,
668 & builtin_core_vs_variables[i]);
669 }
670
671 if (add_deprecated) {
672 for (unsigned i = 0
673 ; i < Elements(builtin_110_deprecated_vs_variables)
674 ; i++) {
675 add_builtin_variable(instructions, state->symbols,
676 & builtin_110_deprecated_vs_variables[i]);
677 }
678 }
679 generate_110_uniforms(instructions, state, add_deprecated);
680
681 /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
682 *
683 * "As with all arrays, indices used to subscript gl_TexCoord must
684 * either be an integral constant expressions, or this array must be
685 * re-declared by the shader with a size. The size can be at most
686 * gl_MaxTextureCoords. Using indexes close to 0 may aid the
687 * implementation in preserving varying resources."
688 */
689 const glsl_type *const vec4_array_type =
690 glsl_type::get_array_instance(glsl_type::vec4_type, 0);
691
692 add_variable(instructions, state->symbols,
693 "gl_TexCoord", vec4_array_type, ir_var_out, VERT_RESULT_TEX0);
694
695 generate_ARB_draw_buffers_variables(instructions, state, false,
696 vertex_shader);
697 }
698
699
700 static void
generate_120_vs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)701 generate_120_vs_variables(exec_list *instructions,
702 struct _mesa_glsl_parse_state *state,
703 bool add_deprecated)
704 {
705 /* GLSL version 1.20 did not add any built-in variables in the vertex
706 * shader.
707 */
708 generate_110_vs_variables(instructions, state, add_deprecated);
709 }
710
711
712 static void
generate_130_uniforms(exec_list * instructions,struct _mesa_glsl_parse_state * state)713 generate_130_uniforms(exec_list *instructions,
714 struct _mesa_glsl_parse_state *state)
715 {
716 glsl_symbol_table *const symtab = state->symbols;
717
718 add_builtin_constant(instructions, symtab, "gl_MaxClipDistances",
719 state->Const.MaxClipPlanes);
720 add_builtin_constant(instructions, symtab, "gl_MaxVaryingComponents",
721 state->Const.MaxVaryingFloats);
722 }
723
724
725 static void
generate_130_vs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)726 generate_130_vs_variables(exec_list *instructions,
727 struct _mesa_glsl_parse_state *state,
728 bool add_deprecated)
729 {
730 generate_120_vs_variables(instructions, state, add_deprecated);
731
732 for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
733 add_builtin_variable(instructions, state->symbols,
734 & builtin_130_vs_variables[i]);
735 }
736
737 generate_130_uniforms(instructions, state);
738
739 /* From the GLSL 1.30 spec, section 7.1 (Vertex Shader Special
740 * Variables):
741 *
742 * The gl_ClipDistance array is predeclared as unsized and must
743 * be sized by the shader either redeclaring it with a size or
744 * indexing it only with integral constant expressions.
745 *
746 * We represent this in Mesa by initially declaring the array as
747 * size 0.
748 */
749 const glsl_type *const clip_distance_array_type =
750 glsl_type::get_array_instance(glsl_type::float_type, 0);
751
752 add_variable(instructions, state->symbols,
753 "gl_ClipDistance", clip_distance_array_type, ir_var_out,
754 VERT_RESULT_CLIP_DIST0);
755
756 }
757
758
759 static void
initialize_vs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)760 initialize_vs_variables(exec_list *instructions,
761 struct _mesa_glsl_parse_state *state)
762 {
763
764 switch (state->language_version) {
765 case 100:
766 generate_100ES_vs_variables(instructions, state);
767 break;
768 case 110:
769 generate_110_vs_variables(instructions, state, true);
770 break;
771 case 120:
772 generate_120_vs_variables(instructions, state, true);
773 break;
774 case 130:
775 generate_130_vs_variables(instructions, state, true);
776 break;
777 case 140:
778 generate_130_vs_variables(instructions, state, false);
779 break;
780 }
781
782 generate_ARB_draw_instanced_variables(instructions, state, false,
783 vertex_shader);
784 }
785
786
787 /* This function should only be called for ES, not desktop GL. */
788 static void
generate_100ES_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)789 generate_100ES_fs_variables(exec_list *instructions,
790 struct _mesa_glsl_parse_state *state)
791 {
792 for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
793 add_builtin_variable(instructions, state->symbols,
794 & builtin_core_fs_variables[i]);
795 }
796
797 for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
798 add_builtin_variable(instructions, state->symbols,
799 & builtin_100ES_fs_variables[i]);
800 }
801
802 generate_100ES_uniforms(instructions, state);
803
804 generate_ARB_draw_buffers_variables(instructions, state, false,
805 fragment_shader);
806 }
807
808 static void
generate_110_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)809 generate_110_fs_variables(exec_list *instructions,
810 struct _mesa_glsl_parse_state *state,
811 bool add_deprecated)
812 {
813 for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
814 add_builtin_variable(instructions, state->symbols,
815 & builtin_core_fs_variables[i]);
816 }
817
818 for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
819 add_builtin_variable(instructions, state->symbols,
820 & builtin_110_fs_variables[i]);
821 }
822
823 if (add_deprecated) {
824 for (unsigned i = 0
825 ; i < Elements(builtin_110_deprecated_fs_variables)
826 ; i++) {
827 add_builtin_variable(instructions, state->symbols,
828 & builtin_110_deprecated_fs_variables[i]);
829 }
830 }
831
832 generate_110_uniforms(instructions, state, add_deprecated);
833
834 /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
835 *
836 * "As with all arrays, indices used to subscript gl_TexCoord must
837 * either be an integral constant expressions, or this array must be
838 * re-declared by the shader with a size. The size can be at most
839 * gl_MaxTextureCoords. Using indexes close to 0 may aid the
840 * implementation in preserving varying resources."
841 */
842 const glsl_type *const vec4_array_type =
843 glsl_type::get_array_instance(glsl_type::vec4_type, 0);
844
845 add_variable(instructions, state->symbols,
846 "gl_TexCoord", vec4_array_type, ir_var_in, FRAG_ATTRIB_TEX0);
847
848 generate_ARB_draw_buffers_variables(instructions, state, false,
849 fragment_shader);
850 }
851
852
853 static void
generate_ARB_draw_buffers_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool warn,_mesa_glsl_parser_targets target)854 generate_ARB_draw_buffers_variables(exec_list *instructions,
855 struct _mesa_glsl_parse_state *state,
856 bool warn, _mesa_glsl_parser_targets target)
857 {
858 /* gl_MaxDrawBuffers is available in all shader stages.
859 */
860 ir_variable *const mdb =
861 add_builtin_constant(instructions, state->symbols, "gl_MaxDrawBuffers",
862 state->Const.MaxDrawBuffers);
863
864 if (warn)
865 mdb->warn_extension = "GL_ARB_draw_buffers";
866
867 /* gl_FragData is only available in the fragment shader.
868 */
869 if (target == fragment_shader) {
870 const glsl_type *const vec4_array_type =
871 glsl_type::get_array_instance(glsl_type::vec4_type,
872 state->Const.MaxDrawBuffers);
873
874 ir_variable *const fd =
875 add_variable(instructions, state->symbols,
876 "gl_FragData", vec4_array_type,
877 ir_var_out, FRAG_RESULT_DATA0);
878
879 if (warn)
880 fd->warn_extension = "GL_ARB_draw_buffers";
881 }
882 }
883
884
885 static void
generate_ARB_draw_instanced_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool warn,_mesa_glsl_parser_targets target)886 generate_ARB_draw_instanced_variables(exec_list *instructions,
887 struct _mesa_glsl_parse_state *state,
888 bool warn,
889 _mesa_glsl_parser_targets target)
890 {
891 /* gl_InstanceIDARB is only available in the vertex shader.
892 */
893 if (target != vertex_shader)
894 return;
895
896 if (state->ARB_draw_instanced_enable) {
897 ir_variable *inst =
898 add_variable(instructions, state->symbols,
899 "gl_InstanceIDARB", glsl_type::int_type,
900 ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
901
902 if (warn)
903 inst->warn_extension = "GL_ARB_draw_instanced";
904 }
905
906 if (state->ARB_draw_instanced_enable || state->language_version >= 140) {
907 /* Originally ARB_draw_instanced only specified that ARB decorated name.
908 * Since no vendor actually implemented that behavior and some apps use
909 * the undecorated name, the extension now specifies that both names are
910 * available.
911 */
912 ir_variable *inst =
913 add_variable(instructions, state->symbols,
914 "gl_InstanceID", glsl_type::int_type,
915 ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
916
917 if (state->language_version < 140 && warn)
918 inst->warn_extension = "GL_ARB_draw_instanced";
919 }
920 }
921
922
923 static void
generate_ARB_shader_stencil_export_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool warn)924 generate_ARB_shader_stencil_export_variables(exec_list *instructions,
925 struct _mesa_glsl_parse_state *state,
926 bool warn)
927 {
928 /* gl_FragStencilRefARB is only available in the fragment shader.
929 */
930 ir_variable *const fd =
931 add_variable(instructions, state->symbols,
932 "gl_FragStencilRefARB", glsl_type::int_type,
933 ir_var_out, FRAG_RESULT_STENCIL);
934
935 if (warn)
936 fd->warn_extension = "GL_ARB_shader_stencil_export";
937 }
938
939 static void
generate_AMD_shader_stencil_export_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool warn)940 generate_AMD_shader_stencil_export_variables(exec_list *instructions,
941 struct _mesa_glsl_parse_state *state,
942 bool warn)
943 {
944 /* gl_FragStencilRefAMD is only available in the fragment shader.
945 */
946 ir_variable *const fd =
947 add_variable(instructions, state->symbols,
948 "gl_FragStencilRefAMD", glsl_type::int_type,
949 ir_var_out, FRAG_RESULT_STENCIL);
950
951 if (warn)
952 fd->warn_extension = "GL_AMD_shader_stencil_export";
953 }
954
955 static void
generate_120_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state,bool add_deprecated)956 generate_120_fs_variables(exec_list *instructions,
957 struct _mesa_glsl_parse_state *state,
958 bool add_deprecated)
959 {
960 generate_110_fs_variables(instructions, state, add_deprecated);
961
962 for (unsigned i = 0
963 ; i < Elements(builtin_120_fs_variables)
964 ; i++) {
965 add_builtin_variable(instructions, state->symbols,
966 & builtin_120_fs_variables[i]);
967 }
968 }
969
970 static void
generate_fs_clipdistance(exec_list * instructions,struct _mesa_glsl_parse_state * state)971 generate_fs_clipdistance(exec_list *instructions,
972 struct _mesa_glsl_parse_state *state)
973 {
974 /* From the GLSL 1.30 spec, section 7.2 (Fragment Shader Special
975 * Variables):
976 *
977 * The built-in input variable gl_ClipDistance array contains linearly
978 * interpolated values for the vertex values written by the vertex shader
979 * to the gl_ClipDistance vertex output variable. This array must be
980 * sized in the fragment shader either implicitly or explicitly to be the
981 * same size as it was sized in the vertex shader.
982 *
983 * In other words, the array must be pre-declared as implicitly sized. We
984 * represent this in Mesa by initially declaring the array as size 0.
985 */
986 const glsl_type *const clip_distance_array_type =
987 glsl_type::get_array_instance(glsl_type::float_type, 0);
988
989 add_variable(instructions, state->symbols,
990 "gl_ClipDistance", clip_distance_array_type, ir_var_in,
991 FRAG_ATTRIB_CLIP_DIST0);
992 }
993
994 static void
generate_130_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)995 generate_130_fs_variables(exec_list *instructions,
996 struct _mesa_glsl_parse_state *state)
997 {
998 generate_120_fs_variables(instructions, state, true);
999
1000 generate_130_uniforms(instructions, state);
1001 generate_fs_clipdistance(instructions, state);
1002 }
1003
1004
1005 static void
generate_140_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)1006 generate_140_fs_variables(exec_list *instructions,
1007 struct _mesa_glsl_parse_state *state)
1008 {
1009 generate_120_fs_variables(instructions, state, false);
1010
1011 generate_130_uniforms(instructions, state);
1012 generate_fs_clipdistance(instructions, state);
1013 }
1014
1015 static void
initialize_fs_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)1016 initialize_fs_variables(exec_list *instructions,
1017 struct _mesa_glsl_parse_state *state)
1018 {
1019
1020 switch (state->language_version) {
1021 case 100:
1022 generate_100ES_fs_variables(instructions, state);
1023 break;
1024 case 110:
1025 generate_110_fs_variables(instructions, state, true);
1026 break;
1027 case 120:
1028 generate_120_fs_variables(instructions, state, true);
1029 break;
1030 case 130:
1031 generate_130_fs_variables(instructions, state);
1032 break;
1033 case 140:
1034 generate_140_fs_variables(instructions, state);
1035 break;
1036 }
1037
1038 if (state->ARB_shader_stencil_export_enable)
1039 generate_ARB_shader_stencil_export_variables(instructions, state,
1040 state->ARB_shader_stencil_export_warn);
1041
1042 if (state->AMD_shader_stencil_export_enable)
1043 generate_AMD_shader_stencil_export_variables(instructions, state,
1044 state->AMD_shader_stencil_export_warn);
1045 }
1046
1047 void
_mesa_glsl_initialize_variables(exec_list * instructions,struct _mesa_glsl_parse_state * state)1048 _mesa_glsl_initialize_variables(exec_list *instructions,
1049 struct _mesa_glsl_parse_state *state)
1050 {
1051 switch (state->target) {
1052 case vertex_shader:
1053 initialize_vs_variables(instructions, state);
1054 break;
1055 case geometry_shader:
1056 break;
1057 case fragment_shader:
1058 initialize_fs_variables(instructions, state);
1059 break;
1060 }
1061 }
1062