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
  29 static void generate_ARB_draw_buffers_variables(exec_list *,
  30                                                 struct _mesa_glsl_parse_state *,
  31                                                 bool, _mesa_glsl_parser_targets);
  32
  33 static ir_variable *
  34 add_variable(const char *name, enum ir_variable_mode mode, int slot,
  35              const glsl_type *type, exec_list *instructions,
  36                      glsl_symbol_table *symtab)
  37 {
  38    ir_variable *var = new(symtab) ir_variable(type, name, mode);
  39
  40    switch (var->mode) {
  41    case ir_var_auto:
  42    case ir_var_in:
  43    case ir_var_uniform:
  44       var->read_only = true;
  45       break;
  46    case ir_var_inout:
  47    case ir_var_out:
  48       break;
  49    default:
  50       assert(0);
  51       break;
  52    }
  53
  54    var->location = slot;
  55
  56    /* Once the variable is created an initialized, add it to the symbol table
  57     * and add the declaration to the IR stream.
  58     */
  59    instructions->push_tail(var);
  60
  61    symtab->add_variable(var->name, var);
  62    return var;
  63 }
  64
  65 static ir_variable *
  66 add_uniform(exec_list *instructions,
  67             struct _mesa_glsl_parse_state *state,
  68             const char *name, const glsl_type *type)
  69 {
  70    return add_variable(name, ir_var_uniform, -1, type, instructions,
  71                        state->symbols);
  72 }
  73
  74 static void
  75 add_builtin_variable(const builtin_variable *proto, exec_list *instructions,
  76                      glsl_symbol_table *symtab)
  77 {
  78    /* Create a new variable declaration from the description supplied by
  79     * the caller.
  80     */
  81    const glsl_type *const type = symtab->get_type(proto->type);
  82
  83    assert(type != NULL);
  84
  85    add_variable(proto->name, proto->mode, proto->slot, type, instructions,
  86                 symtab);
  87 }
  88
  89 static void
  90 add_builtin_constant(exec_list *instructions,
  91                      struct _mesa_glsl_parse_state *state,
  92                      const char *name, int value)
  93 {
  94    ir_variable *const var = add_variable(name, ir_var_auto,
  95                                          -1, glsl_type::int_type,
  96                                          instructions, state->symbols);
  97    var->constant_value = new(var) ir_constant(value);
  98 }
  99
 100 /* Several constants in GLSL ES have different names than normal desktop GLSL.
 101  * Therefore, this function should only be called on the ES path.
 102  */
 103 static void
 104 generate_100ES_uniforms(exec_list *instructions,
 105                      struct _mesa_glsl_parse_state *state)
 106 {
 107    add_builtin_constant(instructions, state, "gl_MaxVertexAttribs",
 108                         state->Const.MaxVertexAttribs);
 109    add_builtin_constant(instructions, state, "gl_MaxVertexUniformVectors",
 110                         state->Const.MaxVertexUniformComponents);
 111    add_builtin_constant(instructions, state, "gl_MaxVaryingVectors",
 112                         state->Const.MaxVaryingFloats / 4);
 113    add_builtin_constant(instructions, state, "gl_MaxVertexTextureImageUnits",
 114                         state->Const.MaxVertexTextureImageUnits);
 115    add_builtin_constant(instructions, state, "gl_MaxCombinedTextureImageUnits",
 116                         state->Const.MaxCombinedTextureImageUnits);
 117    add_builtin_constant(instructions, state, "gl_MaxTextureImageUnits",
 118                         state->Const.MaxTextureImageUnits);
 119    add_builtin_constant(instructions, state, "gl_MaxFragmentUniformVectors",
 120                         state->Const.MaxFragmentUniformComponents);
 121
 122    add_uniform(instructions, state, "gl_DepthRange",
 123                state->symbols->get_type("gl_DepthRangeParameters"));
 124 }
 125
 126 static void
 127 generate_110_uniforms(exec_list *instructions,
 128                       struct _mesa_glsl_parse_state *state)
 129 {
 130    for (unsigned i = 0
 131            ; i < Elements(builtin_110_deprecated_uniforms)
 132            ; i++) {
 133       add_builtin_variable(& builtin_110_deprecated_uniforms[i],
 134                            instructions, state->symbols);
 135    }
 136
 137    add_builtin_constant(instructions, state, "gl_MaxLights",
 138                         state->Const.MaxLights);
 139    add_builtin_constant(instructions, state, "gl_MaxClipPlanes",
 140                         state->Const.MaxClipPlanes);
 141    add_builtin_constant(instructions, state, "gl_MaxTextureUnits",
 142                         state->Const.MaxTextureUnits);
 143    add_builtin_constant(instructions, state, "gl_MaxTextureCoords",
 144                         state->Const.MaxTextureCoords);
 145    add_builtin_constant(instructions, state, "gl_MaxVertexAttribs",
 146                         state->Const.MaxVertexAttribs);
 147    add_builtin_constant(instructions, state, "gl_MaxVertexUniformComponents",
 148                         state->Const.MaxVertexUniformComponents);
 149    add_builtin_constant(instructions, state, "gl_MaxVaryingFloats",
 150                         state->Const.MaxVaryingFloats);
 151    add_builtin_constant(instructions, state, "gl_MaxVertexTextureImageUnits",
 152                         state->Const.MaxVertexTextureImageUnits);
 153    add_builtin_constant(instructions, state, "gl_MaxCombinedTextureImageUnits",
 154                         state->Const.MaxCombinedTextureImageUnits);
 155    add_builtin_constant(instructions, state, "gl_MaxTextureImageUnits",
 156                         state->Const.MaxTextureImageUnits);
 157    add_builtin_constant(instructions, state, "gl_MaxFragmentUniformComponents",
 158                         state->Const.MaxFragmentUniformComponents);
 159
 160    const glsl_type *const mat4_array_type =
 161       glsl_type::get_array_instance(glsl_type::mat4_type,
 162                                     state->Const.MaxTextureCoords);
 163
 164    add_uniform(instructions, state, "gl_TextureMatrix", mat4_array_type);
 165    add_uniform(instructions, state, "gl_TextureMatrixInverse", mat4_array_type);
 166    add_uniform(instructions, state, "gl_TextureMatrixTranspose", mat4_array_type);
 167    add_uniform(instructions, state, "gl_TextureMatrixInverseTranspose", mat4_array_type);
 168
 169    add_uniform(instructions, state, "gl_DepthRange",
 170                 state->symbols->get_type("gl_DepthRangeParameters"));
 171
 172    add_uniform(instructions, state, "gl_ClipPlane",
 173                glsl_type::get_array_instance(glsl_type::vec4_type,
 174                                              state->Const.MaxClipPlanes));
 175    add_uniform(instructions, state, "gl_Point",
 176                state->symbols->get_type("gl_PointParameters"));
 177
 178    const glsl_type *const material_parameters_type =
 179       state->symbols->get_type("gl_MaterialParameters");
 180    add_uniform(instructions, state, "gl_FrontMaterial", material_parameters_type);
 181    add_uniform(instructions, state, "gl_BackMaterial", material_parameters_type);
 182
 183    const glsl_type *const light_source_array_type =
 184       glsl_type::get_array_instance(state->symbols->get_type("gl_LightSourceParameters"), state->Const.MaxLights);
 185
 186    add_uniform(instructions, state, "gl_LightSource", light_source_array_type);
 187
 188    const glsl_type *const light_model_products_type =
 189       state->symbols->get_type("gl_LightModelProducts");
 190    add_uniform(instructions, state, "gl_FrontLightModelProduct",
 191                light_model_products_type);
 192    add_uniform(instructions, state, "gl_BackLightModelProduct",
 193                light_model_products_type);
 194
 195    const glsl_type *const light_products_type =
 196       glsl_type::get_array_instance(state->symbols->get_type("gl_LightProducts"),
 197                                     state->Const.MaxLights);
 198    add_uniform(instructions, state, "gl_FrontLightProduct", light_products_type);
 199    add_uniform(instructions, state, "gl_BackLightProduct", light_products_type);
 200
 201    add_uniform(instructions, state, "gl_TextureEnvColor",
 202                glsl_type::get_array_instance(glsl_type::vec4_type,
 203                                              state->Const.MaxTextureUnits));
 204
 205    const glsl_type *const texcoords_vec4 =
 206       glsl_type::get_array_instance(glsl_type::vec4_type,
 207                                     state->Const.MaxTextureCoords);
 208    add_uniform(instructions, state, "gl_EyePlaneS", texcoords_vec4);
 209    add_uniform(instructions, state, "gl_EyePlaneT", texcoords_vec4);
 210    add_uniform(instructions, state, "gl_EyePlaneR", texcoords_vec4);
 211    add_uniform(instructions, state, "gl_EyePlaneQ", texcoords_vec4);
 212    add_uniform(instructions, state, "gl_ObjectPlaneS", texcoords_vec4);
 213    add_uniform(instructions, state, "gl_ObjectPlaneT", texcoords_vec4);
 214    add_uniform(instructions, state, "gl_ObjectPlaneR", texcoords_vec4);
 215    add_uniform(instructions, state, "gl_ObjectPlaneQ", texcoords_vec4);
 216
 217    add_uniform(instructions, state, "gl_Fog",
 218                state->symbols->get_type("gl_FogParameters"));
 219 }
 220
 221 /* This function should only be called for ES, not desktop GL. */
 222 static void
 223 generate_100ES_vs_variables(exec_list *instructions,
 224                           struct _mesa_glsl_parse_state *state)
 225 {
 226    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 227       add_builtin_variable(& builtin_core_vs_variables[i],
 228                            instructions, state->symbols);
 229    }
 230
 231    generate_100ES_uniforms(instructions, state);
 232
 233    generate_ARB_draw_buffers_variables(instructions, state, false,
 234                                        vertex_shader);
 235 }
 236
 237
 238 static void
 239 generate_110_vs_variables(exec_list *instructions,
 240                           struct _mesa_glsl_parse_state *state)
 241 {
 242    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 243       add_builtin_variable(& builtin_core_vs_variables[i],
 244                            instructions, state->symbols);
 245    }
 246
 247    for (unsigned i = 0
 248            ; i < Elements(builtin_110_deprecated_vs_variables)
 249            ; i++) {
 250       add_builtin_variable(& builtin_110_deprecated_vs_variables[i],
 251                            instructions, state->symbols);
 252    }
 253    generate_110_uniforms(instructions, state);
 254
 255    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 256     *
 257     *     "As with all arrays, indices used to subscript gl_TexCoord must
 258     *     either be an integral constant expressions, or this array must be
 259     *     re-declared by the shader with a size. The size can be at most
 260     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 261     *     implementation in preserving varying resources."
 262     */
 263    const glsl_type *const vec4_array_type =
 264       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 265
 266    add_variable("gl_TexCoord", ir_var_out, VERT_RESULT_TEX0, vec4_array_type,
 267                 instructions, state->symbols);
 268
 269    generate_ARB_draw_buffers_variables(instructions, state, false,
 270                                        vertex_shader);
 271 }
 272
 273
 274 static void
 275 generate_120_vs_variables(exec_list *instructions,
 276                           struct _mesa_glsl_parse_state *state)
 277 {
 278    /* GLSL version 1.20 did not add any built-in variables in the vertex
 279     * shader.
 280     */
 281    generate_110_vs_variables(instructions, state);
 282 }
 283
 284
 285 static void
 286 generate_130_vs_variables(exec_list *instructions,
 287                           struct _mesa_glsl_parse_state *state)
 288 {
 289    generate_120_vs_variables(instructions, state);
 290
 291    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 292       add_builtin_variable(& builtin_130_vs_variables[i],
 293                            instructions, state->symbols);
 294    }
 295
 296    const glsl_type *const clip_distance_array_type =
 297       glsl_type::get_array_instance(glsl_type::float_type,
 298                                     state->Const.MaxClipPlanes);
 299
 300    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 301    add_variable("gl_ClipDistance", ir_var_out, -1, clip_distance_array_type,
 302                 instructions, state->symbols);
 303
 304 }
 305
 306
 307 static void
 308 initialize_vs_variables(exec_list *instructions,
 309                         struct _mesa_glsl_parse_state *state)
 310 {
 311
 312    switch (state->language_version) {
 313    case 100:
 314       generate_100ES_vs_variables(instructions, state);
 315       break;
 316    case 110:
 317       generate_110_vs_variables(instructions, state);
 318       break;
 319    case 120:
 320       generate_120_vs_variables(instructions, state);
 321       break;
 322    case 130:
 323       generate_130_vs_variables(instructions, state);
 324       break;
 325    }
 326 }
 327
 328 /* This function should only be called for ES, not desktop GL. */
 329 static void
 330 generate_100ES_fs_variables(exec_list *instructions,
 331                           struct _mesa_glsl_parse_state *state)
 332 {
 333    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 334       add_builtin_variable(& builtin_core_fs_variables[i],
 335                            instructions, state->symbols);
 336    }
 337
 338    for (unsigned i = 0; i < Elements(builtin_100ES_fs_variables); i++) {
 339       add_builtin_variable(& builtin_100ES_fs_variables[i],
 340                            instructions, state->symbols);
 341    }
 342
 343    generate_100ES_uniforms(instructions, state);
 344
 345    generate_ARB_draw_buffers_variables(instructions, state, false,
 346                                        fragment_shader);
 347 }
 348
 349 static void
 350 generate_110_fs_variables(exec_list *instructions,
 351                           struct _mesa_glsl_parse_state *state)
 352 {
 353    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 354       add_builtin_variable(& builtin_core_fs_variables[i],
 355                            instructions, state->symbols);
 356    }
 357
 358    for (unsigned i = 0; i < Elements(builtin_110_fs_variables); i++) {
 359       add_builtin_variable(& builtin_110_fs_variables[i],
 360                            instructions, state->symbols);
 361    }
 362
 363    for (unsigned i = 0
 364            ; i < Elements(builtin_110_deprecated_fs_variables)
 365            ; i++) {
 366       add_builtin_variable(& builtin_110_deprecated_fs_variables[i],
 367                            instructions, state->symbols);
 368    }
 369    generate_110_uniforms(instructions, state);
 370
 371    /* From page 54 (page 60 of the PDF) of the GLSL 1.20 spec:
 372     *
 373     *     "As with all arrays, indices used to subscript gl_TexCoord must
 374     *     either be an integral constant expressions, or this array must be
 375     *     re-declared by the shader with a size. The size can be at most
 376     *     gl_MaxTextureCoords. Using indexes close to 0 may aid the
 377     *     implementation in preserving varying resources."
 378     */
 379    const glsl_type *const vec4_array_type =
 380       glsl_type::get_array_instance(glsl_type::vec4_type, 0);
 381
 382    add_variable("gl_TexCoord", ir_var_in, FRAG_ATTRIB_TEX0, vec4_array_type,
 383                 instructions, state->symbols);
 384
 385    generate_ARB_draw_buffers_variables(instructions, state, false,
 386                                        fragment_shader);
 387 }
 388
 389
 390 static void
 391 generate_ARB_draw_buffers_variables(exec_list *instructions,
 392                                     struct _mesa_glsl_parse_state *state,
 393                                     bool warn, _mesa_glsl_parser_targets target)
 394 {
 395    /* gl_MaxDrawBuffers is available in all shader stages.
 396     */
 397    ir_variable *const mdb =
 398       add_variable("gl_MaxDrawBuffers", ir_var_auto, -1,
 399                    glsl_type::int_type, instructions, state->symbols);
 400
 401    if (warn)
 402       mdb->warn_extension = "GL_ARB_draw_buffers";
 403
 404    mdb->constant_value = new(mdb)
 405       ir_constant(int(state->Const.MaxDrawBuffers));
 406
 407
 408    /* gl_FragData is only available in the fragment shader.
 409     */
 410    if (target == fragment_shader) {
 411       const glsl_type *const vec4_array_type =
 412          glsl_type::get_array_instance(glsl_type::vec4_type,
 413                                        state->Const.MaxDrawBuffers);
 414
 415       ir_variable *const fd =
 416          add_variable("gl_FragData", ir_var_out, FRAG_RESULT_DATA0,
 417                       vec4_array_type, instructions, state->symbols);
 418
 419       if (warn)
 420          fd->warn_extension = "GL_ARB_draw_buffers";
 421    }
 422 }
 423
 424
 425 static void
 426 generate_120_fs_variables(exec_list *instructions,
 427                           struct _mesa_glsl_parse_state *state)
 428 {
 429    generate_110_fs_variables(instructions, state);
 430
 431    for (unsigned i = 0
 432            ; i < Elements(builtin_120_fs_variables)
 433            ; i++) {
 434       add_builtin_variable(& builtin_120_fs_variables[i],
 435                            instructions, state->symbols);
 436    }
 437 }
 438
 439 static void
 440 generate_130_fs_variables(exec_list *instructions,
 441                           struct _mesa_glsl_parse_state *state)
 442 {
 443    generate_120_fs_variables(instructions, state);
 444
 445    const glsl_type *const clip_distance_array_type =
 446       glsl_type::get_array_instance(glsl_type::float_type,
 447                                     state->Const.MaxClipPlanes);
 448
 449    /* FINISHME: gl_ClipDistance needs a real location assigned. */
 450    add_variable("gl_ClipDistance", ir_var_in, -1, clip_distance_array_type,
 451                 instructions, state->symbols);
 452 }
 453
 454 static void
 455 initialize_fs_variables(exec_list *instructions,
 456                         struct _mesa_glsl_parse_state *state)
 457 {
 458
 459    switch (state->language_version) {
 460    case 100:
 461       generate_100ES_fs_variables(instructions, state);
 462       break;
 463    case 110:
 464       generate_110_fs_variables(instructions, state);
 465       break;
 466    case 120:
 467       generate_120_fs_variables(instructions, state);
 468       break;
 469    case 130:
 470       generate_130_fs_variables(instructions, state);
 471       break;
 472    }
 473 }
 474
 475 void
 476 _mesa_glsl_initialize_variables(exec_list *instructions,
 477                                 struct _mesa_glsl_parse_state *state)
 478 {
 479    switch (state->target) {
 480    case vertex_shader:
 481       initialize_vs_variables(instructions, state);
 482       break;
 483    case geometry_shader:
 484       break;
 485    case fragment_shader:
 486       initialize_fs_variables(instructions, state);
 487       break;
 488    case ir_shader:
 489       fprintf(stderr, "ir reader has no builtin variables");
 490       exit(1);
 491       break;
 492    }
 493 }