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 33static void generate_ARB_draw_buffers_variables(exec_list *, 34 struct _mesa_glsl_parse_state *, 35 bool, _mesa_glsl_parser_targets); 36 37static void 38generate_ARB_draw_instanced_variables(exec_list *, 39 struct _mesa_glsl_parse_state *, 40 bool, _mesa_glsl_parser_targets); 41 42struct builtin_variable { 43 enum ir_variable_mode mode; 44 int slot; 45 const char *type; 46 const char *name; 47}; 48 49static 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 54static 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 60static const builtin_variable builtin_100ES_fs_variables[] = { 61 { ir_var_in, FRAG_ATTRIB_PNTC, "vec2", "gl_PointCoord" }, 62}; 63 64static const builtin_variable builtin_110_fs_variables[] = { 65 { ir_var_out, FRAG_RESULT_DEPTH, "float", "gl_FragDepth" }, 66}; 67 68static 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 74static 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 96static const builtin_variable builtin_120_fs_variables[] = { 97 { ir_var_in, FRAG_ATTRIB_PNTC, "vec2", "gl_PointCoord" }, 98}; 99 100static const builtin_variable builtin_130_vs_variables[] = { 101 { ir_var_system_value, SYSTEM_VALUE_VERTEX_ID, "int", "gl_VertexID" }, 102}; 103 104static 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 127static 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 133static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = { 134 {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW} 135}; 136 137static 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 147static 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 155static 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 163static 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 182static struct gl_builtin_uniform_element gl_LightModel_elements[] = { 183 {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW}, 184}; 185 186static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = { 187 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW}, 188}; 189 190static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = { 191 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW}, 192}; 193 194static 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 200static 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 206static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = { 207 {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW}, 208}; 209 210static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = { 211 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW}, 212}; 213 214static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = { 215 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW}, 216}; 217 218static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = { 219 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW}, 220}; 221 222static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = { 223 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW}, 224}; 225 226static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = { 227 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW}, 228}; 229 230static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = { 231 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW}, 232}; 233 234static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = { 235 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW}, 236}; 237 238static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = { 239 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW}, 240}; 241 242static 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 250static struct gl_builtin_uniform_element gl_NormalScale_elements[] = { 251 {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX}, 252}; 253 254static struct gl_builtin_uniform_element gl_BumpRotMatrix0MESA_elements[] = { 255 {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW}, 256}; 257 258static struct gl_builtin_uniform_element gl_BumpRotMatrix1MESA_elements[] = { 259 {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW}, 260}; 261 262static struct gl_builtin_uniform_element gl_FogParamsOptimizedMESA_elements[] = { 263 {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW}, 264}; 265 266static struct gl_builtin_uniform_element gl_CurrentAttribVertMESA_elements[] = { 267 {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB, 0}, SWIZZLE_XYZW}, 268}; 269 270static 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 282MATRIX(gl_ModelViewMatrix, 283 STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE); 284MATRIX(gl_ModelViewMatrixInverse, 285 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS); 286MATRIX(gl_ModelViewMatrixTranspose, 287 STATE_MODELVIEW_MATRIX, 0); 288MATRIX(gl_ModelViewMatrixInverseTranspose, 289 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE); 290 291MATRIX(gl_ProjectionMatrix, 292 STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE); 293MATRIX(gl_ProjectionMatrixInverse, 294 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS); 295MATRIX(gl_ProjectionMatrixTranspose, 296 STATE_PROJECTION_MATRIX, 0); 297MATRIX(gl_ProjectionMatrixInverseTranspose, 298 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE); 299 300MATRIX(gl_ModelViewProjectionMatrix, 301 STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE); 302MATRIX(gl_ModelViewProjectionMatrixInverse, 303 STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS); 304MATRIX(gl_ModelViewProjectionMatrixTranspose, 305 STATE_MVP_MATRIX, 0); 306MATRIX(gl_ModelViewProjectionMatrixInverseTranspose, 307 STATE_MVP_MATRIX, STATE_MATRIX_INVERSE); 308 309MATRIX(gl_TextureMatrix, 310 STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE); 311MATRIX(gl_TextureMatrixInverse, 312 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS); 313MATRIX(gl_TextureMatrixTranspose, 314 STATE_TEXTURE_MATRIX, 0); 315MATRIX(gl_TextureMatrixInverseTranspose, 316 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE); 317 318static 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 331const 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 386static ir_variable * 387add_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 422static ir_variable * 423add_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 470static void 471add_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 489static ir_variable * 490add_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 */ 505static void 506generate_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 530static void 531generate_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. */ 645static void 646generate_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 661static void 662generate_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 700static void 701generate_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 712static void 713generate_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 725static void 726generate_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 759static void 760initialize_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. */ 788static void 789generate_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 808static void 809generate_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 853static void 854generate_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 885static void 886generate_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 923static void 924generate_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 939static void 940generate_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 955static void 956generate_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 970static void 971generate_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 994static void 995generate_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 1005static void 1006generate_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 1015static void 1016initialize_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 1047void 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