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
  40 /**
  41  * Declarations of type flyweights (glsl_type::_foo_type) and
  42  * convenience pointers (glsl_type::foo_type).
  43  * @{
  44  */
  45 #define DECL_TYPE(NAME, ...)                                    \
  46    const glsl_type glsl_type::_##NAME##_type = glsl_type(__VA_ARGS__, #NAME); \
  47    const glsl_type *const glsl_type::NAME##_type = &glsl_type::_##NAME##_type;
  48
  49 #define STRUCT_TYPE(NAME)                                       \
  50    const glsl_type glsl_type::_struct_##NAME##_type =           \
  51       glsl_type(NAME##_fields, Elements(NAME##_fields), #NAME); \
  52    const glsl_type *const glsl_type::struct_##NAME##_type =     \
  53       &glsl_type::_struct_##NAME##_type;
  54
  55 static const struct glsl_struct_field gl_DepthRangeParameters_fields[] = {
  56    { glsl_type::float_type, "near", false, -1 },
  57    { glsl_type::float_type, "far",  false, -1 },
  58    { glsl_type::float_type, "diff", false, -1 },
  59 };
  60
  61 static const struct glsl_struct_field gl_PointParameters_fields[] = {
  62    { glsl_type::float_type, "size", false, -1 },
  63    { glsl_type::float_type, "sizeMin", false, -1 },
  64    { glsl_type::float_type, "sizeMax", false, -1 },
  65    { glsl_type::float_type, "fadeThresholdSize", false, -1 },
  66    { glsl_type::float_type, "distanceConstantAttenuation", false, -1 },
  67    { glsl_type::float_type, "distanceLinearAttenuation", false, -1 },
  68    { glsl_type::float_type, "distanceQuadraticAttenuation", false, -1 },
  69 };
  70
  71 static const struct glsl_struct_field gl_MaterialParameters_fields[] = {
  72    { glsl_type::vec4_type, "emission", false, -1 },
  73    { glsl_type::vec4_type, "ambient", false, -1 },
  74    { glsl_type::vec4_type, "diffuse", false, -1 },
  75    { glsl_type::vec4_type, "specular", false, -1 },
  76    { glsl_type::float_type, "shininess", false, -1 },
  77 };
  78
  79 static const struct glsl_struct_field gl_LightSourceParameters_fields[] = {
  80    { glsl_type::vec4_type, "ambient", false, -1 },
  81    { glsl_type::vec4_type, "diffuse", false, -1 },
  82    { glsl_type::vec4_type, "specular", false, -1 },
  83    { glsl_type::vec4_type, "position", false, -1 },
  84    { glsl_type::vec4_type, "halfVector", false, -1 },
  85    { glsl_type::vec3_type, "spotDirection", false, -1 },
  86    { glsl_type::float_type, "spotExponent", false, -1 },
  87    { glsl_type::float_type, "spotCutoff", false, -1 },
  88    { glsl_type::float_type, "spotCosCutoff", false, -1 },
  89    { glsl_type::float_type, "constantAttenuation", false, -1 },
  90    { glsl_type::float_type, "linearAttenuation", false, -1 },
  91    { glsl_type::float_type, "quadraticAttenuation", false, -1 },
  92 };
  93
  94 static const struct glsl_struct_field gl_LightModelParameters_fields[] = {
  95    { glsl_type::vec4_type, "ambient", false, -1 },
  96 };
  97
  98 static const struct glsl_struct_field gl_LightModelProducts_fields[] = {
  99    { glsl_type::vec4_type, "sceneColor", false, -1 },
 100 };
 101
 102 static const struct glsl_struct_field gl_LightProducts_fields[] = {
 103    { glsl_type::vec4_type, "ambient", false, -1 },
 104    { glsl_type::vec4_type, "diffuse", false, -1 },
 105    { glsl_type::vec4_type, "specular", false, -1 },
 106 };
 107
 108 static const struct glsl_struct_field gl_FogParameters_fields[] = {
 109    { glsl_type::vec4_type, "color", false, -1 },
 110    { glsl_type::float_type, "density", false, -1 },
 111    { glsl_type::float_type, "start", false, -1 },
 112    { glsl_type::float_type, "end", false, -1 },
 113    { glsl_type::float_type, "scale", false, -1 },
 114 };
 115
 116 #include "builtin_type_macros.h"
 117 /** @} */
 118
 119 /**
 120  * Code to populate a symbol table with the built-in types available in a
 121  * particular shading language version.  The table below contains tags every
 122  * type with the GLSL/GLSL ES versions where it was introduced.
 123  *
 124  * @{
 125  */
 126 #define T(TYPE, MIN_GL, MIN_ES) \
 127    { glsl_type::TYPE##_type, MIN_GL, MIN_ES },
 128
 129 const static struct builtin_type_versions {
 130    const glsl_type *const type;
 131    int min_gl;
 132    int min_es;
 133 } builtin_type_versions[] = {
 134    T(void,                            110, 100)
 135    T(bool,                            110, 100)
 136    T(bvec2,                           110, 100)
 137    T(bvec3,                           110, 100)
 138    T(bvec4,                           110, 100)
 139    T(int,                             110, 100)
 140    T(ivec2,                           110, 100)
 141    T(ivec3,                           110, 100)
 142    T(ivec4,                           110, 100)
 143    T(uint,                            130, 300)
 144    T(uvec2,                           130, 300)
 145    T(uvec3,                           130, 300)
 146    T(uvec4,                           130, 300)
 147    T(float,                           110, 100)
 148    T(vec2,                            110, 100)
 149    T(vec3,                            110, 100)
 150    T(vec4,                            110, 100)
 151    T(mat2,                            110, 100)
 152    T(mat3,                            110, 100)
 153    T(mat4,                            110, 100)
 154    T(mat2x3,                          120, 300)
 155    T(mat2x4,                          120, 300)
 156    T(mat3x2,                          120, 300)
 157    T(mat3x4,                          120, 300)
 158    T(mat4x2,                          120, 300)
 159    T(mat4x3,                          120, 300)
 160
 161    T(sampler1D,                       110, 999)
 162    T(sampler2D,                       110, 100)
 163    T(sampler3D,                       110, 300)
 164    T(samplerCube,                     110, 100)
 165    T(sampler1DArray,                  130, 999)
 166    T(sampler2DArray,                  130, 300)
 167    T(samplerCubeArray,                400, 999)
 168    T(sampler2DRect,                   140, 999)
 169    T(samplerBuffer,                   140, 999)
 170    T(sampler2DMS,                     150, 999)
 171    T(sampler2DMSArray,                150, 999)
 172
 173    T(isampler1D,                      130, 999)
 174    T(isampler2D,                      130, 300)
 175    T(isampler3D,                      130, 300)
 176    T(isamplerCube,                    130, 300)
 177    T(isampler1DArray,                 130, 999)
 178    T(isampler2DArray,                 130, 300)
 179    T(isamplerCubeArray,               400, 999)
 180    T(isampler2DRect,                  140, 999)
 181    T(isamplerBuffer,                  140, 999)
 182    T(isampler2DMS,                    150, 999)
 183    T(isampler2DMSArray,               150, 999)
 184
 185    T(usampler1D,                      130, 999)
 186    T(usampler2D,                      130, 300)
 187    T(usampler3D,                      130, 300)
 188    T(usamplerCube,                    130, 300)
 189    T(usampler1DArray,                 130, 999)
 190    T(usampler2DArray,                 130, 300)
 191    T(usamplerCubeArray,               400, 999)
 192    T(usampler2DRect,                  140, 999)
 193    T(usamplerBuffer,                  140, 999)
 194    T(usampler2DMS,                    150, 999)
 195    T(usampler2DMSArray,               150, 999)
 196
 197    T(sampler1DShadow,                 110, 999)
 198    T(sampler2DShadow,                 110, 300)
 199    T(samplerCubeShadow,               130, 300)
 200    T(sampler1DArrayShadow,            130, 999)
 201    T(sampler2DArrayShadow,            130, 300)
 202    T(samplerCubeArrayShadow,          400, 999)
 203    T(sampler2DRectShadow,             140, 999)
 204
 205    T(struct_gl_DepthRangeParameters,  110, 100)
 206
 207    T(atomic_uint,                     420, 999)
 208 };
 209
 210 const glsl_type *const deprecated_types[] = {
 211    glsl_type::struct_gl_PointParameters_type,
 212    glsl_type::struct_gl_MaterialParameters_type,
 213    glsl_type::struct_gl_LightSourceParameters_type,
 214    glsl_type::struct_gl_LightModelParameters_type,
 215    glsl_type::struct_gl_LightModelProducts_type,
 216    glsl_type::struct_gl_LightProducts_type,
 217    glsl_type::struct_gl_FogParameters_type,
 218 };
 219
 220 static inline void
 221 add_type(glsl_symbol_table *symbols, const glsl_type *const type)
 222 {
 223    symbols->add_type(type->name, type);
 224 }
 225
 226 /**
 227  * Populate the symbol table with available built-in types.
 228  */
 229 void
 230 _mesa_glsl_initialize_types(struct _mesa_glsl_parse_state *state)
 231 {
 232    struct glsl_symbol_table *symbols = state->symbols;
 233
 234    for (unsigned i = 0; i < Elements(builtin_type_versions); i++) {
 235       const struct builtin_type_versions *const t = &builtin_type_versions[i];
 236       if (state->is_version(t->min_gl, t->min_es)) {
 237          add_type(symbols, t->type);
 238       }
 239    }
 240
 241    /* Add deprecated structure types.  While these were deprecated in 1.30,
 242     * they're still present.  We've removed them in 1.40+ (OpenGL 3.1+).
 243     */
 244    if (!state->es_shader && state->language_version < 140) {
 245       for (unsigned i = 0; i < Elements(deprecated_types); i++) {
 246          add_type(symbols, deprecated_types[i]);
 247       }
 248    }
 249
 250    /* Add types for enabled extensions.  They may have already been added
 251     * by the version-based loop, but attempting to add them a second time
 252     * is harmless.
 253     */
 254    if (state->ARB_texture_cube_map_array_enable) {
 255       add_type(symbols, glsl_type::samplerCubeArray_type);
 256       add_type(symbols, glsl_type::samplerCubeArrayShadow_type);
 257       add_type(symbols, glsl_type::isamplerCubeArray_type);
 258       add_type(symbols, glsl_type::usamplerCubeArray_type);
 259    }
 260
 261    if (state->ARB_texture_multisample_enable) {
 262       add_type(symbols, glsl_type::sampler2DMS_type);
 263       add_type(symbols, glsl_type::isampler2DMS_type);
 264       add_type(symbols, glsl_type::usampler2DMS_type);
 265       add_type(symbols, glsl_type::sampler2DMSArray_type);
 266       add_type(symbols, glsl_type::isampler2DMSArray_type);
 267       add_type(symbols, glsl_type::usampler2DMSArray_type);
 268    }
 269
 270    if (state->ARB_texture_rectangle_enable) {
 271       add_type(symbols, glsl_type::sampler2DRect_type);
 272       add_type(symbols, glsl_type::sampler2DRectShadow_type);
 273    }
 274
 275    if (state->EXT_texture_array_enable) {
 276       add_type(symbols, glsl_type::sampler1DArray_type);
 277       add_type(symbols, glsl_type::sampler2DArray_type);
 278       add_type(symbols, glsl_type::sampler1DArrayShadow_type);
 279       add_type(symbols, glsl_type::sampler2DArrayShadow_type);
 280    }
 281
 282    if (state->OES_EGL_image_external_enable) {
 283       add_type(symbols, glsl_type::samplerExternalOES_type);
 284    }
 285
 286    if (state->OES_texture_3D_enable) {
 287       add_type(symbols, glsl_type::sampler3D_type);
 288    }
 289
 290    if (state->ARB_shader_atomic_counters_enable) {
 291       add_type(symbols, glsl_type::atomic_uint_type);
 292    }
 293 }
 294 /** @} */