src/glsl/builtin_types.cpp

   1 /*
   2  * Copyright © 2013 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 /**
  25  * \file builtin_types.cpp
  26  *
  27  * The glsl_type class has static members to represent all the built-in types
  28  * (such as the glsl_type::_float_type flyweight) as well as convenience pointer
  29  * accessors (such as glsl_type::float_type).  Those global variables are
  30  * declared and initialized in this file.
  31  *
  32  * This also contains _mesa_glsl_initialize_types(), a function which populates
  33  * a symbol table with the available built-in types for a particular language
  34  * version and set of enabled extensions.
  35  */
  36
  37 #include "glsl_types.h"
  38 #include "glsl_parser_extras.h"
  39 #include "util/macros.h"
  40
  41 /**
  42  * Declarations of type flyweights (glsl_type::_foo_type) and
  43  * convenience pointers (glsl_type::foo_type).
  44  * @{
  45  */
  46 #define DECL_TYPE(NAME, ...)                                    \
  47    const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \
  48    const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type;
  49
  50 #define STRUCT_TYPE(NAME)                                       \
  51    const glsl_type glsl_type::_struct_##NAME##_type =           \
  52       glsl_type(NAME##_fields, ARRAY_SIZE(NAME##_fields), #NAME); \
  53    const glsl_type *const glsl_type::struct_##NAME##_type =     \
  54       &glsl_type::_struct_##NAME##_type;
  55
  56 static const struct glsl_struct_field gl_DepthRangeParameters_fields[] = {
  57    { glsl_type::float_type, "near", false, -1 },
  58    { glsl_type::float_type, "far",  false, -1 },
  59    { glsl_type::float_type, "diff", false, -1 },
  60 };
  61
  62 static const struct glsl_struct_field gl_PointParameters_fields[] = {
  63    { glsl_type::float_type, "size", false, -1 },
  64    { glsl_type::float_type, "sizeMin", false, -1 },
  65    { glsl_type::float_type, "sizeMax", false, -1 },
  66    { glsl_type::float_type, "fadeThresholdSize", false, -1 },
  67    { glsl_type::float_type, "distanceConstantAttenuation", false, -1 },
  68    { glsl_type::float_type, "distanceLinearAttenuation", false, -1 },
  69    { glsl_type::float_type, "distanceQuadraticAttenuation", false, -1 },
  70 };
  71
  72 static const struct glsl_struct_field gl_MaterialParameters_fields[] = {
  73    { glsl_type::vec4_type, "emission", false, -1 },
  74    { glsl_type::vec4_type, "ambient", false, -1 },
  75    { glsl_type::vec4_type, "diffuse", false, -1 },
  76    { glsl_type::vec4_type, "specular", false, -1 },
  77    { glsl_type::float_type, "shininess", false, -1 },
  78 };
  79
  80 static const struct glsl_struct_field gl_LightSourceParameters_fields[] = {
  81    { glsl_type::vec4_type, "ambient", false, -1 },
  82    { glsl_type::vec4_type, "diffuse", false, -1 },
  83    { glsl_type::vec4_type, "specular", false, -1 },
  84    { glsl_type::vec4_type, "position", false, -1 },
  85    { glsl_type::vec4_type, "halfVector", false, -1 },
  86    { glsl_type::vec3_type, "spotDirection", false, -1 },
  87    { glsl_type::float_type, "spotExponent", false, -1 },
  88    { glsl_type::float_type, "spotCutoff", false, -1 },
  89    { glsl_type::float_type, "spotCosCutoff", false, -1 },
  90    { glsl_type::float_type, "constantAttenuation", false, -1 },
  91    { glsl_type::float_type, "linearAttenuation", false, -1 },
  92    { glsl_type::float_type, "quadraticAttenuation", false, -1 },
  93 };
  94
  95 static const struct glsl_struct_field gl_LightModelParameters_fields[] = {
  96    { glsl_type::vec4_type, "ambient", false, -1 },
  97 };
  98
  99 static const struct glsl_struct_field gl_LightModelProducts_fields[] = {
 100    { glsl_type::vec4_type, "sceneColor", false, -1 },
 101 };
 102
 103 static const struct glsl_struct_field gl_LightProducts_fields[] = {
 104    { glsl_type::vec4_type, "ambient", false, -1 },
 105    { glsl_type::vec4_type, "diffuse", false, -1 },
 106    { glsl_type::vec4_type, "specular", false, -1 },
 107 };
 108
 109 static const struct glsl_struct_field gl_FogParameters_fields[] = {
 110    { glsl_type::vec4_type, "color", false, -1 },
 111    { glsl_type::float_type, "density", false, -1 },
 112    { glsl_type::float_type, "start", false, -1 },
 113    { glsl_type::float_type, "end", false, -1 },
 114    { glsl_type::float_type, "scale", false, -1 },
 115 };
 116
 117 #include "builtin_type_macros.h"
 118 /** @} */
 119
 120 /**
 121  * Code to populate a symbol table with the built-in types available in a
 122  * particular shading language version.  The table below contains tags every
 123  * type with the GLSL/GLSL ES versions where it was introduced.
 124  *
 125  * @{
 126  */
 127 #define T(TYPE, MIN_GL, MIN_ES) \
 128    { glsl_type::TYPE##_type, MIN_GL, MIN_ES },
 129
 130 const static struct builtin_type_versions {
 131    const glsl_type *const type;
 132    int min_gl;
 133    int min_es;
 134 } builtin_type_versions[] = {
 135    T(void,                            110, 100)
 136    T(bool,                            110, 100)
 137    T(bvec2,                           110, 100)
 138    T(bvec3,                           110, 100)
 139    T(bvec4,                           110, 100)
 140    T(int,                             110, 100)
 141    T(ivec2,                           110, 100)
 142    T(ivec3,                           110, 100)
 143    T(ivec4,                           110, 100)
 144    T(uint,                            130, 300)
 145    T(uvec2,                           130, 300)
 146    T(uvec3,                           130, 300)
 147    T(uvec4,                           130, 300)
 148    T(float,                           110, 100)
 149    T(vec2,                            110, 100)
 150    T(vec3,                            110, 100)
 151    T(vec4,                            110, 100)
 152    T(mat2,                            110, 100)
 153    T(mat3,                            110, 100)
 154    T(mat4,                            110, 100)
 155    T(mat2x3,                          120, 300)
 156    T(mat2x4,                          120, 300)
 157    T(mat3x2,                          120, 300)
 158    T(mat3x4,                          120, 300)
 159    T(mat4x2,                          120, 300)
 160    T(mat4x3,                          120, 300)
 161
 162    T(sampler1D,                       110, 999)
 163    T(sampler2D,                       110, 100)
 164    T(sampler3D,                       110, 300)
 165    T(samplerCube,                     110, 100)
 166    T(sampler1DArray,                  130, 999)
 167    T(sampler2DArray,                  130, 300)
 168    T(samplerCubeArray,                400, 999)
 169    T(sampler2DRect,                   140, 999)
 170    T(samplerBuffer,                   140, 999)
 171    T(sampler2DMS,                     150, 999)
 172    T(sampler2DMSArray,                150, 999)
 173
 174    T(isampler1D,                      130, 999)
 175    T(isampler2D,                      130, 300)
 176    T(isampler3D,                      130, 300)
 177    T(isamplerCube,                    130, 300)
 178    T(isampler1DArray,                 130, 999)
 179    T(isampler2DArray,                 130, 300)
 180    T(isamplerCubeArray,               400, 999)
 181    T(isampler2DRect,                  140, 999)
 182    T(isamplerBuffer,                  140, 999)
 183    T(isampler2DMS,                    150, 999)
 184    T(isampler2DMSArray,               150, 999)
 185
 186    T(usampler1D,                      130, 999)
 187    T(usampler2D,                      130, 300)
 188    T(usampler3D,                      130, 300)
 189    T(usamplerCube,                    130, 300)
 190    T(usampler1DArray,                 130, 999)
 191    T(usampler2DArray,                 130, 300)
 192    T(usamplerCubeArray,               400, 999)
 193    T(usampler2DRect,                  140, 999)
 194    T(usamplerBuffer,                  140, 999)
 195    T(usampler2DMS,                    150, 999)
 196    T(usampler2DMSArray,               150, 999)
 197
 198    T(sampler1DShadow,                 110, 999)
 199    T(sampler2DShadow,                 110, 300)
 200    T(samplerCubeShadow,               130, 300)
 201    T(sampler1DArrayShadow,            130, 999)
 202    T(sampler2DArrayShadow,            130, 300)
 203    T(samplerCubeArrayShadow,          400, 999)
 204    T(sampler2DRectShadow,             140, 999)
 205
 206    T(struct_gl_DepthRangeParameters,  110, 100)
 207
 208    T(image1D,                         420, 999)
 209    T(image2D,                         420, 999)
 210    T(image3D,                         420, 999)
 211    T(image2DRect,                     420, 999)
 212    T(imageCube,                       420, 999)
 213    T(imageBuffer,                     420, 999)
 214    T(image1DArray,                    420, 999)
 215    T(image2DArray,                    420, 999)
 216    T(imageCubeArray,                  420, 999)
 217    T(image2DMS,                       420, 999)
 218    T(image2DMSArray,                  420, 999)
 219    T(iimage1D,                        420, 999)
 220    T(iimage2D,                        420, 999)
 221    T(iimage3D,                        420, 999)
 222    T(iimage2DRect,                    420, 999)
 223    T(iimageCube,                      420, 999)
 224    T(iimageBuffer,                    420, 999)
 225    T(iimage1DArray,                   420, 999)
 226    T(iimage2DArray,                   420, 999)
 227    T(iimageCubeArray,                 420, 999)
 228    T(iimage2DMS,                      420, 999)
 229    T(iimage2DMSArray,                 420, 999)
 230    T(uimage1D,                        420, 999)
 231    T(uimage2D,                        420, 999)
 232    T(uimage3D,                        420, 999)
 233    T(uimage2DRect,                    420, 999)
 234    T(uimageCube,                      420, 999)
 235    T(uimageBuffer,                    420, 999)
 236    T(uimage1DArray,                   420, 999)
 237    T(uimage2DArray,                   420, 999)
 238    T(uimageCubeArray,                 420, 999)
 239    T(uimage2DMS,                      420, 999)
 240    T(uimage2DMSArray,                 420, 999)
 241
 242    T(atomic_uint,                     420, 999)
 243 };
 244
 245 static const glsl_type *const deprecated_types[] = {
 246    glsl_type::struct_gl_PointParameters_type,
 247    glsl_type::struct_gl_MaterialParameters_type,
 248    glsl_type::struct_gl_LightSourceParameters_type,
 249    glsl_type::struct_gl_LightModelParameters_type,
 250    glsl_type::struct_gl_LightModelProducts_type,
 251    glsl_type::struct_gl_LightProducts_type,
 252    glsl_type::struct_gl_FogParameters_type,
 253 };
 254
 255 static inline void
 256 add_type(glsl_symbol_table *symbols, const glsl_type *const type)
 257 {
 258    symbols->add_type(type->name, type);
 259 }
 260
 261 /**
 262  * Populate the symbol table with available built-in types.
 263  */
 264 void
 265 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state)
 266 {
 267    struct glsl_symbol_table *symbols = state->symbols;
 268
 269    for (unsigned i = 0; i < ARRAY_SIZE(builtin_type_versions); i++) {
 270       const struct builtin_type_versions *const t = &builtin_type_versions[i];
 271       if (state->is_version(t->min_gl, t->min_es)) {
 272          add_type(symbols, t->type);
 273       }
 274    }
 275
 276    /* Add deprecated structure types.  While these were deprecated in 1.30,
 277     * they're still present.  We've removed them in 1.40+ (OpenGL 3.1+).
 278     */
 279    if (!state->es_shader && state->language_version < 140) {
 280       for (unsigned i = 0; i < ARRAY_SIZE(deprecated_types); i++) {
 281          add_type(symbols, deprecated_types[i]);
 282       }
 283    }
 284
 285    /* Add types for enabled extensions.  They may have already been added
 286     * by the version-based loop, but attempting to add them a second time
 287     * is harmless.
 288     */
 289    if (state->ARB_texture_cube_map_array_enable) {
 290       add_type(symbols, glsl_type::samplerCubeArray_type);
 291       add_type(symbols, glsl_type::samplerCubeArrayShadow_type);
 292       add_type(symbols, glsl_type::isamplerCubeArray_type);
 293       add_type(symbols, glsl_type::usamplerCubeArray_type);
 294    }
 295
 296    if (state->ARB_texture_multisample_enable) {
 297       add_type(symbols, glsl_type::sampler2DMS_type);
 298       add_type(symbols, glsl_type::isampler2DMS_type);
 299       add_type(symbols, glsl_type::usampler2DMS_type);
 300       add_type(symbols, glsl_type::sampler2DMSArray_type);
 301       add_type(symbols, glsl_type::isampler2DMSArray_type);
 302       add_type(symbols, glsl_type::usampler2DMSArray_type);
 303    }
 304
 305    if (state->ARB_texture_rectangle_enable) {
 306       add_type(symbols, glsl_type::sampler2DRect_type);
 307       add_type(symbols, glsl_type::sampler2DRectShadow_type);
 308    }
 309
 310    if (state->EXT_texture_array_enable) {
 311       add_type(symbols, glsl_type::sampler1DArray_type);
 312       add_type(symbols, glsl_type::sampler2DArray_type);
 313       add_type(symbols, glsl_type::sampler1DArrayShadow_type);
 314       add_type(symbols, glsl_type::sampler2DArrayShadow_type);
 315    }
 316
 317    if (state->OES_EGL_image_external_enable) {
 318       add_type(symbols, glsl_type::samplerExternalOES_type);
 319    }
 320
 321    if (state->OES_texture_3D_enable) {
 322       add_type(symbols, glsl_type::sampler3D_type);
 323    }
 324
 325    if (state->ARB_shader_image_load_store_enable) {
 326       add_type(symbols, glsl_type::image1D_type);
 327       add_type(symbols, glsl_type::image2D_type);
 328       add_type(symbols, glsl_type::image3D_type);
 329       add_type(symbols, glsl_type::image2DRect_type);
 330       add_type(symbols, glsl_type::imageCube_type);
 331       add_type(symbols, glsl_type::imageBuffer_type);
 332       add_type(symbols, glsl_type::image1DArray_type);
 333       add_type(symbols, glsl_type::image2DArray_type);
 334       add_type(symbols, glsl_type::imageCubeArray_type);
 335       add_type(symbols, glsl_type::image2DMS_type);
 336       add_type(symbols, glsl_type::image2DMSArray_type);
 337       add_type(symbols, glsl_type::iimage1D_type);
 338       add_type(symbols, glsl_type::iimage2D_type);
 339       add_type(symbols, glsl_type::iimage3D_type);
 340       add_type(symbols, glsl_type::iimage2DRect_type);
 341       add_type(symbols, glsl_type::iimageCube_type);
 342       add_type(symbols, glsl_type::iimageBuffer_type);
 343       add_type(symbols, glsl_type::iimage1DArray_type);
 344       add_type(symbols, glsl_type::iimage2DArray_type);
 345       add_type(symbols, glsl_type::iimageCubeArray_type);
 346       add_type(symbols, glsl_type::iimage2DMS_type);
 347       add_type(symbols, glsl_type::iimage2DMSArray_type);
 348       add_type(symbols, glsl_type::uimage1D_type);
 349       add_type(symbols, glsl_type::uimage2D_type);
 350       add_type(symbols, glsl_type::uimage3D_type);
 351       add_type(symbols, glsl_type::uimage2DRect_type);
 352       add_type(symbols, glsl_type::uimageCube_type);
 353       add_type(symbols, glsl_type::uimageBuffer_type);
 354       add_type(symbols, glsl_type::uimage1DArray_type);
 355       add_type(symbols, glsl_type::uimage2DArray_type);
 356       add_type(symbols, glsl_type::uimageCubeArray_type);
 357       add_type(symbols, glsl_type::uimage2DMS_type);
 358       add_type(symbols, glsl_type::uimage2DMSArray_type);
 359    }
 360
 361    if (state->ARB_shader_atomic_counters_enable) {
 362       add_type(symbols, glsl_type::atomic_uint_type);
 363    }
 364 }
 365 /** @} */