src/glsl/ir_variable.cpp

   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 "builtin_variables.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 static struct gl_builtin_uniform_element gl_DepthRange_elements[] = {
  43    {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX},
  44    {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY},
  45    {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ},
  46 };
  47
  48 static struct gl_builtin_uniform_element gl_ClipPlane_elements[] = {
  49    {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW}
  50 };
  51
  52 static struct gl_builtin_uniform_element gl_Point_elements[] = {
  53    {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX},
  54    {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY},
  55    {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ},
  56    {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW},
  57    {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX},
  58    {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY},
  59    {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ},
  60 };
  61
  62 static struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = {
  63    {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW},
  64    {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
  65    {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
  66    {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
  67    {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX},
  68 };
  69
  70 static struct gl_builtin_uniform_element gl_BackMaterial_elements[] = {
  71    {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW},
  72    {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
  73    {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
  74    {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
  75    {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX},
  76 };
  77
  78 static struct gl_builtin_uniform_element gl_LightSource_elements[] = {
  79    {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
  80    {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
  81    {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
  82    {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW},
  83    {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW},
  84    {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION},
  85     MAKE_SWIZZLE4(SWIZZLE_X,
  86                   SWIZZLE_Y,
  87                   SWIZZLE_Z,
  88                   SWIZZLE_Z)},
  89    {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW},
  90    {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX},
  91    {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW},
  92    {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX},
  93    {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY},
  94    {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ},
  95 };
  96
  97 static struct gl_builtin_uniform_element gl_LightModel_elements[] = {
  98    {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW},
  99 };
 100
 101 static struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = {
 102    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW},
 103 };
 104
 105 static struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = {
 106    {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW},
 107 };
 108
 109 static struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = {
 110    {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW},
 111    {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW},
 112    {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW},
 113 };
 114
 115 static struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = {
 116    {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW},
 117    {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW},
 118    {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW},
 119 };
 120
 121 static struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = {
 122    {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW},
 123 };
 124
 125 static struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = {
 126    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW},
 127 };
 128
 129 static struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = {
 130    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW},
 131 };
 132
 133 static struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = {
 134    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW},
 135 };
 136
 137 static struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = {
 138    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW},
 139 };
 140
 141 static struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = {
 142    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW},
 143 };
 144
 145 static struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = {
 146    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW},
 147 };
 148
 149 static struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = {
 150    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW},
 151 };
 152
 153 static struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = {
 154    {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW},
 155 };
 156
 157 static struct gl_builtin_uniform_element gl_Fog_elements[] = {
 158    {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW},
 159    {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX},
 160    {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY},
 161    {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ},
 162    {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW},
 163 };
 164
 165 static struct gl_builtin_uniform_element gl_NormalScale_elements[] = {
 166    {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX},
 167 };
 168
 169 static struct gl_builtin_uniform_element gl_MESABumpRotMatrix0_elements[] = {
 170    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_0}, SWIZZLE_XYZW},
 171 };
 172
 173 static struct gl_builtin_uniform_element gl_MESABumpRotMatrix1_elements[] = {
 174    {NULL, {STATE_INTERNAL, STATE_ROT_MATRIX_1}, SWIZZLE_XYZW},
 175 };
 176
 177 static struct gl_builtin_uniform_element gl_MESAFogParamsOptimized_elements[] = {
 178    {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW},
 179 };
 180
 181 #define MATRIX(name, statevar, modifier)                                \
 182    static struct gl_builtin_uniform_element name ## _elements[] = {     \
 183       { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW },           \
 184       { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW },           \
 185       { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW },           \
 186       { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW },           \
 187    }
 188
 189 MATRIX(gl_ModelViewMatrix,
 190        STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE);
 191 MATRIX(gl_ModelViewMatrixInverse,
 192        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS);
 193 MATRIX(gl_ModelViewMatrixTranspose,
 194        STATE_MODELVIEW_MATRIX, 0);
 195 MATRIX(gl_ModelViewMatrixInverseTranspose,
 196        STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE);
 197
 198 MATRIX(gl_ProjectionMatrix,
 199        STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE);
 200 MATRIX(gl_ProjectionMatrixInverse,
 201        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS);
 202 MATRIX(gl_ProjectionMatrixTranspose,
 203        STATE_PROJECTION_MATRIX, 0);
 204 MATRIX(gl_ProjectionMatrixInverseTranspose,
 205        STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE);
 206
 207 MATRIX(gl_ModelViewProjectionMatrix,
 208        STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE);
 209 MATRIX(gl_ModelViewProjectionMatrixInverse,
 210        STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS);
 211 MATRIX(gl_ModelViewProjectionMatrixTranspose,
 212        STATE_MVP_MATRIX, 0);
 213 MATRIX(gl_ModelViewProjectionMatrixInverseTranspose,
 214        STATE_MVP_MATRIX, STATE_MATRIX_INVERSE);
 215
 216 MATRIX(gl_TextureMatrix,
 217        STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE);
 218 MATRIX(gl_TextureMatrixInverse,
 219        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS);
 220 MATRIX(gl_TextureMatrixTranspose,
 221        STATE_TEXTURE_MATRIX, 0);
 222 MATRIX(gl_TextureMatrixInverseTranspose,
 223        STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE);
 224
 225 static struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = {
 226    { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE},
 227      SWIZZLE_XYZW },
 228    { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE},
 229      SWIZZLE_XYZW },
 230    { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE},
 231      SWIZZLE_XYZW },
 232 };
 233
 234 #undef MATRIX
 235
 236 #define STATEVAR(name) {#name, name ## _elements, Elements(name ## _elements)}
 237
 238 const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = {
 239    STATEVAR(gl_DepthRange),
 240    STATEVAR(gl_ClipPlane),
 241    STATEVAR(gl_Point),
 242    STATEVAR(gl_FrontMaterial),
 243    STATEVAR(gl_BackMaterial),
 244    STATEVAR(gl_LightSource),
 245    STATEVAR(gl_LightModel),
 246    STATEVAR(gl_FrontLightModelProduct),
 247    STATEVAR(gl_BackLightModelProduct),
 248    STATEVAR(gl_FrontLightProduct),
 249    STATEVAR(gl_BackLightProduct),
 250    STATEVAR(gl_TextureEnvColor),
 251    STATEVAR(gl_EyePlaneS),
 252    STATEVAR(gl_EyePlaneT),
 253    STATEVAR(gl_EyePlaneR),
 254    STATEVAR(gl_EyePlaneQ),
 255    STATEVAR(gl_ObjectPlaneS),
 256    STATEVAR(gl_ObjectPlaneT),
 257    STATEVAR(gl_ObjectPlaneR),
 258    STATEVAR(gl_ObjectPlaneQ),
 259    STATEVAR(gl_Fog),
 260
 261    STATEVAR(gl_ModelViewMatrix),
 262    STATEVAR(gl_ModelViewMatrixInverse),
 263    STATEVAR(gl_ModelViewMatrixTranspose),
 264    STATEVAR(gl_ModelViewMatrixInverseTranspose),
 265
 266    STATEVAR(gl_ProjectionMatrix),
 267    STATEVAR(gl_ProjectionMatrixInverse),
 268    STATEVAR(gl_ProjectionMatrixTranspose),
 269    STATEVAR(gl_ProjectionMatrixInverseTranspose),
 270
 271    STATEVAR(gl_ModelViewProjectionMatrix),
 272    STATEVAR(gl_ModelViewProjectionMatrixInverse),
 273    STATEVAR(gl_ModelViewProjectionMatrixTranspose),
 274    STATEVAR(gl_ModelViewProjectionMatrixInverseTranspose),
 275
 276    STATEVAR(gl_TextureMatrix),
 277    STATEVAR(gl_TextureMatrixInverse),
 278    STATEVAR(gl_TextureMatrixTranspose),
 279    STATEVAR(gl_TextureMatrixInverseTranspose),
 280
 281    STATEVAR(gl_NormalMatrix),
 282    STATEVAR(gl_NormalScale),
 283
 284    STATEVAR(gl_MESABumpRotMatrix0),
 285    STATEVAR(gl_MESABumpRotMatrix1),
 286    STATEVAR(gl_MESAFogParamsOptimized),
 287
 288    {NULL, NULL, 0}
 289 };
 290
 291 static ir_variable *
 292 add_variable(exec_list *instructions, glsl_symbol_table *symtab,
 293              const char *name, const glsl_type *type,
 294              enum ir_variable_mode mode, int slot)
 295 {
 296    ir_variable *var = new(symtab) ir_variable(type, name, mode);
 297
 298    switch (var->mode) {
 299    case ir_var_auto:
 300    case ir_var_in:
 301    case ir_var_const_in:
 302    case ir_var_uniform:
 303    case ir_var_system_value:
 304       var->read_only = true;
 305       break;
 306    case ir_var_inout:
 307    case ir_var_out:
 308       break;
 309    default:
 310       assert(0);
 311       break;
 312    }
 313
 314    var->location = slot;
 315    var->explicit_location = (slot >= 0);
 316
 317    /* Once the variable is created an initialized, add it to the symbol table
 318     * and add the declaration to the IR stream.
 319     */
 320    instructions->push_tail(var);
 321
 322    symtab->add_variable(var);
 323    return var;
 324 }
 325
 326 static ir_variable *
 327 add_uniform(exec_list *instructions, glsl_symbol_table *symtab,
 328             const char *name, const glsl_type *type)
 329 {
 330    return add_variable(instructions, symtab, name, type, ir_var_uniform, -1);
 331 }
 332
 333 static void
 334 add_builtin_variable(exec_list *instructions, glsl_symbol_table *symtab,
 335                      const builtin_variable *proto)
 336 {
 337    /* Create a new variable declaration from the description supplied by
 338     * the caller.
 339     */
 340    const glsl_type *const type = symtab->get_type(proto->type);
 341
 342    assert(type != NULL);
 343
 344    add_variable(instructions, symtab, proto->name, type, proto->mode,
 345                 proto->slot);
 346 }
 347
 348 static void
 349 add_builtin_constant(exec_list *instructions, glsl_symbol_table *symtab,
 350                      const char *name, int value)
 351 {
 352    ir_variable *const var = add_variable(instructions, symtab,
 353                                          name, glsl_type::int_type,
 354                                          ir_var_auto, -1);
 355    var->constant_value = new(var) ir_constant(value);
 356 }
 357
 358 /* Several constants in GLSL ES have different names than normal desktop GLSL.
 359  * Therefore, this function should only be called on the ES path.
 360  */
 361 static void
 362 generate_100ES_uniforms(exec_list *instructions,
 363                      struct _mesa_glsl_parse_state *state)
 364 {
 365    glsl_symbol_table *const symtab = state->symbols;
 366
 367    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 368                         state->Const.MaxVertexAttribs);
 369    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformVectors",
 370                         state->Const.MaxVertexUniformComponents);
 371    add_builtin_constant(instructions, symtab, "gl_MaxVaryingVectors",
 372                         state->Const.MaxVaryingFloats / 4);
 373    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 374                         state->Const.MaxVertexTextureImageUnits);
 375    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 376                         state->Const.MaxCombinedTextureImageUnits);
 377    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 378                         state->Const.MaxTextureImageUnits);
 379    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformVectors",
 380                         state->Const.MaxFragmentUniformComponents);
 381
 382    add_uniform(instructions, symtab, "gl_DepthRange",
 383                state->symbols->get_type("gl_DepthRangeParameters"));
 384 }
 385
 386 static void
 387 generate_110_uniforms(exec_list *instructions,
 388                       struct _mesa_glsl_parse_state *state)
 389 {
 390    glsl_symbol_table *const symtab = state->symbols;
 391
 392    for (unsigned i = 0
 393            ; i < Elements(builtin_110_deprecated_uniforms)
 394            ; i++) {
 395       add_builtin_variable(instructions, symtab,
 396                            & builtin_110_deprecated_uniforms[i]);
 397    }
 398
 399    add_builtin_constant(instructions, symtab, "gl_MaxLights",
 400                         state->Const.MaxLights);
 401    add_builtin_constant(instructions, symtab, "gl_MaxClipPlanes",
 402                         state->Const.MaxClipPlanes);
 403    add_builtin_constant(instructions, symtab, "gl_MaxTextureUnits",
 404                         state->Const.MaxTextureUnits);
 405    add_builtin_constant(instructions, symtab, "gl_MaxTextureCoords",
 406                         state->Const.MaxTextureCoords);
 407    add_builtin_constant(instructions, symtab, "gl_MaxVertexAttribs",
 408                         state->Const.MaxVertexAttribs);
 409    add_builtin_constant(instructions, symtab, "gl_MaxVertexUniformComponents",
 410                         state->Const.MaxVertexUniformComponents);
 411    add_builtin_constant(instructions, symtab, "gl_MaxVaryingFloats",
 412                         state->Const.MaxVaryingFloats);
 413    add_builtin_constant(instructions, symtab, "gl_MaxVertexTextureImageUnits",
 414                         state->Const.MaxVertexTextureImageUnits);
 415    add_builtin_constant(instructions, symtab, "gl_MaxCombinedTextureImageUnits",
 416                         state->Const.MaxCombinedTextureImageUnits);
 417    add_builtin_constant(instructions, symtab, "gl_MaxTextureImageUnits",
 418                         state->Const.MaxTextureImageUnits);
 419    add_builtin_constant(instructions, symtab, "gl_MaxFragmentUniformComponents",
 420                         state->Const.MaxFragmentUniformComponents);
 421
 422    const glsl_type *const mat4_array_type =
 423       glsl_type::get_array_instance(glsl_type::mat4_type,
 424                                     state->Const.MaxTextureCoords);
 425
 426    add_uniform(instructions, symtab, "gl_TextureMatrix", mat4_array_type);
 427    add_uniform(instructions, symtab, "gl_TextureMatrixInverse", mat4_array_type);
 428    add_uniform(instructions, symtab, "gl_TextureMatrixTranspose", mat4_array_type);
 429    add_uniform(instructions, symtab, "gl_TextureMatrixInverseTranspose", mat4_array_type);
 430
 431    add_uniform(instructions, symtab, "gl_DepthRange",
 432                 symtab->get_type("gl_DepthRangeParameters"));
 433
 434    add_uniform(instructions, symtab, "gl_ClipPlane",
 435                glsl_type::get_array_instance(glsl_type::vec4_type,
 436                                              state->Const.MaxClipPlanes));
 437    add_uniform(instructions, symtab, "gl_Point",
 438                symtab->get_type("gl_PointParameters"));
 439
 440    const glsl_type *const material_parameters_type =
 441       symtab->get_type("gl_MaterialParameters");
 442    add_uniform(instructions, symtab, "gl_FrontMaterial", material_parameters_type);
 443    add_uniform(instructions, symtab, "gl_BackMaterial", material_parameters_type);
 444
 445    const glsl_type *const light_source_array_type =
 446       glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), state->Const.MaxLights);
 447
 448    add_uniform(instructions, symtab, "gl_LightSource", light_source_array_type);
 449
 450    const glsl_type *const light_model_products_type =
 451       symtab->get_type("gl_LightModelProducts");
 452    add_uniform(instructions, symtab, "gl_FrontLightModelProduct",
 453                light_model_products_type);
 454    add_uniform(instructions, symtab, "gl_BackLightModelProduct",
 455                light_model_products_type);
 456
 457    const glsl_type *const light_products_type =
 458       glsl_type::get_array_instance(symtab->get_type("gl_LightProducts"),
 459                                     state->Const.MaxLights);
 460    add_uniform(instructions, symtab, "gl_FrontLightProduct", light_products_type);
 461    add_uniform(instructions, symtab, "gl_BackLightProduct", light_products_type);
 462
 463    add_uniform(instructions, symtab, "gl_TextureEnvColor",
 464                glsl_type::get_array_instance(glsl_type::vec4_type,
 465                                              state->Const.MaxTextureUnits));
 466
 467    const glsl_type *const texcoords_vec4 =
 468       glsl_type::get_array_instance(glsl_type::vec4_type,
 469                                     state->Const.MaxTextureCoords);
 470    add_uniform(instructions, symtab, "gl_EyePlaneS", texcoords_vec4);
 471    add_uniform(instructions, symtab, "gl_EyePlaneT", texcoords_vec4);
 472    add_uniform(instructions, symtab, "gl_EyePlaneR", texcoords_vec4);
 473    add_uniform(instructions, symtab, "gl_EyePlaneQ", texcoords_vec4);
 474    add_uniform(instructions, symtab, "gl_ObjectPlaneS", texcoords_vec4);
 475    add_uniform(instructions, symtab, "gl_ObjectPlaneT", texcoords_vec4);
 476    add_uniform(instructions, symtab, "gl_ObjectPlaneR", texcoords_vec4);
 477    add_uniform(instructions, symtab, "gl_ObjectPlaneQ", texcoords_vec4);
 478
 479    add_uniform(instructions, symtab, "gl_Fog",
 480                symtab->get_type("gl_FogParameters"));
 481 }
 482
 483 /* This function should only be called for ES, not desktop GL. */
 484 static void
 485 generate_100ES_vs_variables(exec_list *instructions,
 486                           struct _mesa_glsl_parse_state *state)
 487 {
 488    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 489       add_builtin_variable(instructions, state->symbols,
 490                            & builtin_core_vs_variables[i]);
 491    }
 492
 493    generate_100ES_uniforms(instructions, state);
 494
 495    generate_ARB_draw_buffers_variables(instructions, state, false,
 496                                        vertex_shader);
 497 }
 498
 499
 500 static void
 501 generate_110_vs_variables(exec_list *instructions,
 502                           struct _mesa_glsl_parse_state *state)
 503 {
 504    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 505       add_builtin_variable(instructions, state->symbols,
 506                            & builtin_core_vs_variables[i]);
 507    }
 508
 509    for (unsigned i = 0
 510            ; i < Elements(builtin_110_deprecated_vs_variables)
 511            ; i++) {
 512       add_builtin_variable(instructions, state->symbols,
 513                            & builtin_110_deprecated_vs_variables[i]);
 514    }
 515    generate_110_uniforms(instructions, state);
 516
 517    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 518     *
 519     *     "As with all arrays, indices used to subscript gl_TexCoord must
 520     *     either be an integral constant expressions, or this array must be
 521     *     re-declared by the shader with a size. The size can be at most
 522     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 523     *     implementation in preserving varying resources."
 524     */
 525    const glsl_type *const vec4_array_type =
 526       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 527
 528    add_variable(instructions, state->symbols,
 529                 "gl_TexCoord", vec4_array_type, ir_var_out, VERT_RESULT_TEX0);
 530
 531    generate_ARB_draw_buffers_variables(instructions, state, false,
 532                                        vertex_shader);
 533 }
 534
 535
 536 static void
 537 generate_120_vs_variables(exec_list *instructions,
 538                           struct _mesa_glsl_parse_state *state)
 539 {
 540    /* GLSL version 1.20 did not add any built-in variables in the vertex
 541     * shader.
 542     */
 543    generate_110_vs_variables(instructions, state);
 544 }
 545
 546
 547 static void
 548 generate_130_vs_variables(exec_list *instructions,
 549                           struct _mesa_glsl_parse_state *state)
 550 {
 551    generate_120_vs_variables(instructions, state);
 552
 553    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 554       add_builtin_variable(instructions, state->symbols,
 555                            & builtin_130_vs_variables[i]);
 556    }
 557
 558    const glsl_type *const clip_distance_array_type =
 559       glsl_type::get_array_instance(glsl_type::float_type,
 560                                     state->Const.MaxClipPlanes);
 561
 562    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 563    add_variable(instructions, state->symbols,
 564                 "gl_ClipDistance", clip_distance_array_type, ir_var_out, -1);
 565
 566 }
 567
 568
 569 static void
 570 initialize_vs_variables(exec_list *instructions,
 571                         struct _mesa_glsl_parse_state *state)
 572 {
 573
 574    switch (state->language_version) {
 575    case 100:
 576       generate_100ES_vs_variables(instructions, state);
 577       break;
 578    case 110:
 579       generate_110_vs_variables(instructions, state);
 580       break;
 581    case 120:
 582       generate_120_vs_variables(instructions, state);
 583       break;
 584    case 130:
 585       generate_130_vs_variables(instructions, state);
 586       break;
 587    }
 588
 589    if (state->ARB_draw_instanced_enable)
 590       generate_ARB_draw_instanced_variables(instructions, state, false,
 591                                             vertex_shader);
 592 }
 593
 594
 595 /* This function should only be called for ES, not desktop GL. */
 596 static void
 597 generate_100ES_fs_variables(exec_list *instructions,
 598                           struct _mesa_glsl_parse_state *state)
 599 {
 600    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 601       add_builtin_variable(instructions, state->symbols,
 602                            & builtin_core_fs_variables[i]);
 603    }
 604
 605    for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
 606       add_builtin_variable(instructions, state->symbols,
 607                            & builtin_100ES_fs_variables[i]);
 608    }
 609
 610    generate_100ES_uniforms(instructions, state);
 611
 612    generate_ARB_draw_buffers_variables(instructions, state, false,
 613                                        fragment_shader);
 614 }
 615
 616 static void
 617 generate_110_fs_variables(exec_list *instructions,
 618                           struct _mesa_glsl_parse_state *state)
 619 {
 620    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 621       add_builtin_variable(instructions, state->symbols,
 622                            & builtin_core_fs_variables[i]);
 623    }
 624
 625    for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
 626       add_builtin_variable(instructions, state->symbols,
 627                            & builtin_110_fs_variables[i]);
 628    }
 629
 630    for (unsigned i = 0
 631            ; i < Elements(builtin_110_deprecated_fs_variables)
 632            ; i++) {
 633       add_builtin_variable(instructions, state->symbols,
 634                            & builtin_110_deprecated_fs_variables[i]);
 635    }
 636    generate_110_uniforms(instructions, state);
 637
 638    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 639     *
 640     *     "As with all arrays, indices used to subscript gl_TexCoord must
 641     *     either be an integral constant expressions, or this array must be
 642     *     re-declared by the shader with a size. The size can be at most
 643     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 644     *     implementation in preserving varying resources."
 645     */
 646    const glsl_type *const vec4_array_type =
 647       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 648
 649    add_variable(instructions, state->symbols,
 650                 "gl_TexCoord", vec4_array_type, ir_var_in, FRAG_ATTRIB_TEX0);
 651
 652    generate_ARB_draw_buffers_variables(instructions, state, false,
 653                                        fragment_shader);
 654 }
 655
 656
 657 static void
 658 generate_ARB_draw_buffers_variables(exec_list *instructions,
 659                                     struct _mesa_glsl_parse_state *state,
 660                                     bool warn, _mesa_glsl_parser_targets target)
 661 {
 662    /* gl_MaxDrawBuffers is available in all shader stages.
 663     */
 664    ir_variable *const mdb =
 665       add_variable(instructions, state->symbols,
 666                    "gl_MaxDrawBuffers", glsl_type::int_type, ir_var_auto, -1);
 667
 668    if (warn)
 669       mdb->warn_extension = "GL_ARB_draw_buffers";
 670
 671    mdb->constant_value = new(mdb)
 672       ir_constant(int(state->Const.MaxDrawBuffers));
 673
 674
 675    /* gl_FragData is only available in the fragment shader.
 676     */
 677    if (target == fragment_shader) {
 678       const glsl_type *const vec4_array_type =
 679          glsl_type::get_array_instance(glsl_type::vec4_type,
 680                                        state->Const.MaxDrawBuffers);
 681
 682       ir_variable *const fd =
 683          add_variable(instructions, state->symbols,
 684                       "gl_FragData", vec4_array_type,
 685                       ir_var_out, FRAG_RESULT_DATA0);
 686
 687       if (warn)
 688          fd->warn_extension = "GL_ARB_draw_buffers";
 689    }
 690 }
 691
 692
 693 static void
 694 generate_ARB_draw_instanced_variables(exec_list *instructions,
 695                                       struct _mesa_glsl_parse_state *state,
 696                                       bool warn,
 697                                       _mesa_glsl_parser_targets target)
 698 {
 699    /* gl_InstanceIDARB is only available in the vertex shader.
 700     */
 701    if (target == vertex_shader) {
 702       ir_variable *const inst =
 703          add_variable(instructions, state->symbols,
 704                       "gl_InstanceIDARB", glsl_type::int_type,
 705                       ir_var_system_value, SYSTEM_VALUE_INSTANCE_ID);
 706
 707       if (warn)
 708          inst->warn_extension = "GL_ARB_draw_instanced";
 709    }
 710 }
 711
 712
 713 static void
 714 generate_ARB_shader_stencil_export_variables(exec_list *instructions,
 715                                              struct _mesa_glsl_parse_state *state,
 716                                              bool warn)
 717 {
 718    /* gl_FragStencilRefARB is only available in the fragment shader.
 719     */
 720    ir_variable *const fd =
 721       add_variable(instructions, state->symbols,
 722                    "gl_FragStencilRefARB", glsl_type::int_type,
 723                    ir_var_out, FRAG_RESULT_STENCIL);
 724
 725    if (warn)
 726       fd->warn_extension = "GL_ARB_shader_stencil_export";
 727 }
 728
 729 static void
 730 generate_120_fs_variables(exec_list *instructions,
 731                           struct _mesa_glsl_parse_state *state)
 732 {
 733    generate_110_fs_variables(instructions, state);
 734
 735    for (unsigned i = 0
 736            ; i < Elements(builtin_120_fs_variables)
 737            ; i++) {
 738       add_builtin_variable(instructions, state->symbols,
 739                            & builtin_120_fs_variables[i]);
 740    }
 741 }
 742
 743 static void
 744 generate_130_fs_variables(exec_list *instructions,
 745                           struct _mesa_glsl_parse_state *state)
 746 {
 747    generate_120_fs_variables(instructions, state);
 748
 749    const glsl_type *const clip_distance_array_type =
 750       glsl_type::get_array_instance(glsl_type::float_type,
 751                                     state->Const.MaxClipPlanes);
 752
 753    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 754    add_variable(instructions, state->symbols,
 755                 "gl_ClipDistance", clip_distance_array_type, ir_var_in, -1);
 756 }
 757
 758 static void
 759 initialize_fs_variables(exec_list *instructions,
 760                         struct _mesa_glsl_parse_state *state)
 761 {
 762
 763    switch (state->language_version) {
 764    case 100:
 765       generate_100ES_fs_variables(instructions, state);
 766       break;
 767    case 110:
 768       generate_110_fs_variables(instructions, state);
 769       break;
 770    case 120:
 771       generate_120_fs_variables(instructions, state);
 772       break;
 773    case 130:
 774       generate_130_fs_variables(instructions, state);
 775       break;
 776    }
 777
 778    if (state->ARB_shader_stencil_export_enable)
 779       generate_ARB_shader_stencil_export_variables(instructions, state,
 780                                                    state->ARB_shader_stencil_export_warn);
 781 }
 782
 783 void
 784 _mesa_glsl_initialize_variables(exec_list *instructions,
 785                                 struct _mesa_glsl_parse_state *state)
 786 {
 787    switch (state->target) {
 788    case vertex_shader:
 789       initialize_vs_variables(instructions, state);
 790       break;
 791    case geometry_shader:
 792       break;
 793    case fragment_shader:
 794       initialize_fs_variables(instructions, state);
 795       break;
 796    }
 797 }