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 #ifndef Elements
  30 #define Elements(x) (sizeof(x)/sizeof(*(x)))
  31 #endif
  32
  33 static ir_variable *
  34 add_variable(const char *name, enum ir_variable_mode mode,
  35              const glsl_type *type, exec_list *instructions,
  36                      glsl_symbol_table *symtab)
  37 {
  38    ir_variable *var = new ir_variable(type, name);
  39
  40    var->mode = mode;
  41    switch (var->mode) {
  42    case ir_var_in:
  43       var->shader_in = true;
  44       var->read_only = true;
  45       break;
  46    case ir_var_inout:
  47       var->shader_in = true;
  48       var->shader_out = true;
  49       break;
  50    case ir_var_out:
  51       var->shader_out = true;
  52       break;
  53    case ir_var_uniform:
  54       var->shader_in = true;
  55       var->read_only = true;
  56       break;
  57    default:
  58       assert(0);
  59       break;
  60    }
  61
  62    /* Once the variable is created an initialized, add it to the symbol table
  63     * and add the declaration to the IR stream.
  64     */
  65    instructions->push_tail(var);
  66
  67    symtab->add_variable(var->name, var);
  68    return var;
  69 }
  70
  71
  72 static void
  73 add_builtin_variable(const builtin_variable *proto, exec_list *instructions,
  74                      glsl_symbol_table *symtab)
  75 {
  76    /* Create a new variable declaration from the description supplied by
  77     * the caller.
  78     */
  79    const glsl_type *const type = symtab->get_type(proto->type);
  80
  81    assert(type != NULL);
  82
  83    add_variable(proto->name, proto->mode, type, instructions, symtab);
  84 }
  85
  86
  87 static void
  88 generate_110_uniforms(exec_list *instructions,
  89                       glsl_symbol_table *symtab)
  90 {
  91    for (unsigned i = 0
  92            ; i < Elements(builtin_110_deprecated_uniforms)
  93            ; i++) {
  94       add_builtin_variable(& builtin_110_deprecated_uniforms[i],
  95                            instructions, symtab);
  96    }
  97
  98    /* FINISHME: The size of this array is implementation dependent based on the
  99     * FINISHME: value of GL_MAX_TEXTURE_COORDS.  Every platform that supports
 100     * FINISHME: GLSL sets GL_MAX_TEXTURE_COORDS to at least 4, so hard-code 4
 101     * FINISHME: for now.
 102     */
 103    const glsl_type *const mat4_array_type =
 104       glsl_type::get_array_instance(glsl_type::mat4_type, 4);
 105
 106    add_variable("gl_TextureMatrix", ir_var_uniform, mat4_array_type,
 107                 instructions, symtab);
 108
 109    /* FINISHME: Add support for gl_DepthRangeParameters */
 110    /* FINISHME: Add support for gl_ClipPlane[] */
 111    /* FINISHME: Add support for gl_PointParameters */
 112
 113    /* FINISHME: Add support for gl_MaterialParameters
 114     * FINISHME: (glFrontMaterial, glBackMaterial)
 115     */
 116
 117    /* FINISHME: The size of this array is implementation dependent based on the
 118     * FINISHME: value of GL_MAX_TEXTURE_LIGHTS.  GL_MAX_TEXTURE_LIGHTS must be
 119     * FINISHME: at least 8, so hard-code 8 for now.
 120     */
 121    const glsl_type *const light_source_array_type =
 122       glsl_type::get_array_instance(symtab->get_type("gl_LightSourceParameters"), 8);
 123
 124    add_variable("gl_LightSource", ir_var_uniform, light_source_array_type,
 125                 instructions, symtab);
 126
 127    /* FINISHME: Add support for gl_LightModel */
 128    /* FINISHME: Add support for gl_FrontLightProduct[], gl_BackLightProduct[] */
 129    /* FINISHME: Add support for gl_TextureEnvColor[] */
 130    /* FINISHME: Add support for gl_ObjectPlane*[], gl_EyePlane*[] */
 131    /* FINISHME: Add support for gl_Fog */
 132 }
 133
 134 static void
 135 generate_110_vs_variables(exec_list *instructions,
 136                           glsl_symbol_table *symtab)
 137 {
 138    for (unsigned i = 0; i < Elements(builtin_core_vs_variables); i++) {
 139       add_builtin_variable(& builtin_core_vs_variables[i],
 140                            instructions, symtab);
 141    }
 142
 143    for (unsigned i = 0
 144            ; i < Elements(builtin_110_deprecated_vs_variables)
 145            ; i++) {
 146       add_builtin_variable(& builtin_110_deprecated_vs_variables[i],
 147                            instructions, symtab);
 148    }
 149    generate_110_uniforms(instructions, symtab);
 150
 151    /* FINISHME: The size of this array is implementation dependent based on the
 152     * FINISHME: value of GL_MAX_TEXTURE_COORDS.  Every platform that supports
 153     * FINISHME: GLSL sets GL_MAX_TEXTURE_COORDS to at least 4, so hard-code 4
 154     * FINISHME: for now.
 155     */
 156    const glsl_type *const vec4_array_type =
 157       glsl_type::get_array_instance(glsl_type::vec4_type, 4);
 158
 159    add_variable("gl_TexCoord", ir_var_out, vec4_array_type, instructions,
 160                 symtab);
 161 }
 162
 163
 164 static void
 165 generate_120_vs_variables(exec_list *instructions,
 166                           glsl_symbol_table *symtab)
 167 {
 168    /* GLSL version 1.20 did not add any built-in variables in the vertex
 169     * shader.
 170     */
 171    generate_110_vs_variables(instructions, symtab);
 172 }
 173
 174
 175 static void
 176 generate_130_vs_variables(exec_list *instructions,
 177                           glsl_symbol_table *symtab)
 178 {
 179    generate_120_vs_variables(instructions, symtab);
 180
 181    for (unsigned i = 0; i < Elements(builtin_130_vs_variables); i++) {
 182       add_builtin_variable(& builtin_130_vs_variables[i],
 183                            instructions, symtab);
 184    }
 185
 186    /* FINISHME: The size of this array is implementation dependent based on
 187     * FINISHME: the value of GL_MAX_CLIP_DISTANCES.
 188     */
 189    const glsl_type *const clip_distance_array_type =
 190       glsl_type::get_array_instance(glsl_type::float_type, 8);
 191    add_variable("gl_ClipDistance", ir_var_out, clip_distance_array_type,
 192                 instructions, symtab);
 193
 194 }
 195
 196
 197 static void
 198 initialize_vs_variables(exec_list *instructions,
 199                         struct _mesa_glsl_parse_state *state)
 200 {
 201
 202    switch (state->language_version) {
 203    case 110:
 204       generate_110_vs_variables(instructions, state->symbols);
 205       break;
 206    case 120:
 207       generate_120_vs_variables(instructions, state->symbols);
 208       break;
 209    case 130:
 210       generate_130_vs_variables(instructions, state->symbols);
 211       break;
 212    }
 213 }
 214
 215 static void
 216 generate_110_fs_variables(exec_list *instructions,
 217                           glsl_symbol_table *symtab)
 218 {
 219    for (unsigned i = 0; i < Elements(builtin_core_fs_variables); i++) {
 220       add_builtin_variable(& builtin_core_fs_variables[i],
 221                            instructions, symtab);
 222    }
 223
 224    for (unsigned i = 0
 225            ; i < Elements(builtin_110_deprecated_fs_variables)
 226            ; i++) {
 227       add_builtin_variable(& builtin_110_deprecated_fs_variables[i],
 228                            instructions, symtab);
 229    }
 230    generate_110_uniforms(instructions, symtab);
 231
 232    /* FINISHME: The size of this array is implementation dependent based on the
 233     * FINISHME: value of GL_MAX_TEXTURE_COORDS.  Every platform that supports
 234     * FINISHME: GLSL sets GL_MAX_TEXTURE_COORDS to at least 4, so hard-code 4
 235     * FINISHME: for now.
 236     */
 237    const glsl_type *const vec4_array_type =
 238       glsl_type::get_array_instance(glsl_type::vec4_type, 4);
 239
 240    add_variable("gl_TexCoord", ir_var_in, vec4_array_type, instructions,
 241                 symtab);
 242 }
 243
 244
 245 static void
 246 generate_ARB_draw_buffers_fs_variables(exec_list *instructions,
 247                                        glsl_symbol_table *symtab, bool warn)
 248 {
 249    /* FINISHME: The size of this array is implementation dependent based on the
 250     * FINISHME: value of GL_MAX_DRAW_BUFFERS.  GL_MAX_DRAW_BUFFERS must be
 251     * FINISHME: at least 1, so hard-code 1 for now.
 252     */
 253    const glsl_type *const vec4_array_type =
 254       glsl_type::get_array_instance(glsl_type::vec4_type, 1);
 255
 256    ir_variable *const fd =
 257       add_variable("gl_FragData", ir_var_out, vec4_array_type, instructions,
 258                    symtab);
 259
 260    if (warn)
 261       fd->warn_extension = "GL_ARB_draw_buffers";
 262 }
 263
 264
 265 static void
 266 generate_120_fs_variables(exec_list *instructions,
 267                           glsl_symbol_table *symtab)
 268 {
 269    generate_110_fs_variables(instructions, symtab);
 270    generate_ARB_draw_buffers_fs_variables(instructions, symtab, false);
 271 }
 272
 273 static void
 274 generate_130_fs_variables(exec_list *instructions,
 275                           glsl_symbol_table *symtab)
 276 {
 277    generate_120_fs_variables(instructions, symtab);
 278
 279    /* FINISHME: The size of this array is implementation dependent based on
 280     * FINISHME: the value of GL_MAX_CLIP_DISTANCES.
 281     */
 282    const glsl_type *const clip_distance_array_type =
 283       glsl_type::get_array_instance(glsl_type::float_type, 8);
 284    add_variable("gl_ClipDistance", ir_var_in, clip_distance_array_type,
 285                 instructions, symtab);
 286 }
 287
 288 static void
 289 initialize_fs_variables(exec_list *instructions,
 290                         struct _mesa_glsl_parse_state *state)
 291 {
 292
 293    switch (state->language_version) {
 294    case 110:
 295       generate_110_fs_variables(instructions, state->symbols);
 296       break;
 297    case 120:
 298       generate_120_fs_variables(instructions, state->symbols);
 299       break;
 300    case 130:
 301       generate_130_fs_variables(instructions, state->symbols);
 302       break;
 303    }
 304
 305
 306    /* Since GL_ARB_draw_buffers is included in GLSL 1.20 and later, we
 307     * can basically ignore any extension settings for it.
 308     */
 309    if (state->language_version < 120) {
 310       if (state->ARB_draw_buffers_enable) {
 311          generate_ARB_draw_buffers_fs_variables(instructions, state->symbols,
 312                                                 state->ARB_draw_buffers_warn);
 313       }
 314    }
 315 }
 316
 317 void
 318 _mesa_glsl_initialize_variables(exec_list *instructions,
 319                                 struct _mesa_glsl_parse_state *state)
 320 {
 321    switch (state->target) {
 322    case vertex_shader:
 323       initialize_vs_variables(instructions, state);
 324       break;
 325    case geometry_shader:
 326       break;
 327    case fragment_shader:
 328       initialize_fs_variables(instructions, state);
 329       break;
 330    case ir_shader:
 331       fprintf(stderr, "ir reader has no builtin variables");
 332       exit(1);
 333       break;
 334    }
 335 }