builtin_variables.cpp revision 01e04c3f
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 "ir_builder.h" 26#include "linker.h" 27#include "glsl_parser_extras.h" 28#include "glsl_symbol_table.h" 29#include "main/mtypes.h" 30#include "main/uniforms.h" 31#include "program/prog_statevars.h" 32#include "program/prog_instruction.h" 33#include "builtin_functions.h" 34 35using namespace ir_builder; 36 37static const struct gl_builtin_uniform_element gl_NumSamples_elements[] = { 38 {NULL, {STATE_NUM_SAMPLES, 0, 0}, SWIZZLE_XXXX} 39}; 40 41static const struct gl_builtin_uniform_element gl_DepthRange_elements[] = { 42 {"near", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_XXXX}, 43 {"far", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_YYYY}, 44 {"diff", {STATE_DEPTH_RANGE, 0, 0}, SWIZZLE_ZZZZ}, 45}; 46 47static const struct gl_builtin_uniform_element gl_ClipPlane_elements[] = { 48 {NULL, {STATE_CLIPPLANE, 0, 0}, SWIZZLE_XYZW} 49}; 50 51static const struct gl_builtin_uniform_element gl_Point_elements[] = { 52 {"size", {STATE_POINT_SIZE}, SWIZZLE_XXXX}, 53 {"sizeMin", {STATE_POINT_SIZE}, SWIZZLE_YYYY}, 54 {"sizeMax", {STATE_POINT_SIZE}, SWIZZLE_ZZZZ}, 55 {"fadeThresholdSize", {STATE_POINT_SIZE}, SWIZZLE_WWWW}, 56 {"distanceConstantAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_XXXX}, 57 {"distanceLinearAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_YYYY}, 58 {"distanceQuadraticAttenuation", {STATE_POINT_ATTENUATION}, SWIZZLE_ZZZZ}, 59}; 60 61static const struct gl_builtin_uniform_element gl_FrontMaterial_elements[] = { 62 {"emission", {STATE_MATERIAL, 0, STATE_EMISSION}, SWIZZLE_XYZW}, 63 {"ambient", {STATE_MATERIAL, 0, STATE_AMBIENT}, SWIZZLE_XYZW}, 64 {"diffuse", {STATE_MATERIAL, 0, STATE_DIFFUSE}, SWIZZLE_XYZW}, 65 {"specular", {STATE_MATERIAL, 0, STATE_SPECULAR}, SWIZZLE_XYZW}, 66 {"shininess", {STATE_MATERIAL, 0, STATE_SHININESS}, SWIZZLE_XXXX}, 67}; 68 69static const struct gl_builtin_uniform_element gl_BackMaterial_elements[] = { 70 {"emission", {STATE_MATERIAL, 1, STATE_EMISSION}, SWIZZLE_XYZW}, 71 {"ambient", {STATE_MATERIAL, 1, STATE_AMBIENT}, SWIZZLE_XYZW}, 72 {"diffuse", {STATE_MATERIAL, 1, STATE_DIFFUSE}, SWIZZLE_XYZW}, 73 {"specular", {STATE_MATERIAL, 1, STATE_SPECULAR}, SWIZZLE_XYZW}, 74 {"shininess", {STATE_MATERIAL, 1, STATE_SHININESS}, SWIZZLE_XXXX}, 75}; 76 77static const struct gl_builtin_uniform_element gl_LightSource_elements[] = { 78 {"ambient", {STATE_LIGHT, 0, STATE_AMBIENT}, SWIZZLE_XYZW}, 79 {"diffuse", {STATE_LIGHT, 0, STATE_DIFFUSE}, SWIZZLE_XYZW}, 80 {"specular", {STATE_LIGHT, 0, STATE_SPECULAR}, SWIZZLE_XYZW}, 81 {"position", {STATE_LIGHT, 0, STATE_POSITION}, SWIZZLE_XYZW}, 82 {"halfVector", {STATE_LIGHT, 0, STATE_HALF_VECTOR}, SWIZZLE_XYZW}, 83 {"spotDirection", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, 84 MAKE_SWIZZLE4(SWIZZLE_X, 85 SWIZZLE_Y, 86 SWIZZLE_Z, 87 SWIZZLE_Z)}, 88 {"spotExponent", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_WWWW}, 89 {"spotCutoff", {STATE_LIGHT, 0, STATE_SPOT_CUTOFF}, SWIZZLE_XXXX}, 90 {"spotCosCutoff", {STATE_LIGHT, 0, STATE_SPOT_DIRECTION}, SWIZZLE_WWWW}, 91 {"constantAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_XXXX}, 92 {"linearAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_YYYY}, 93 {"quadraticAttenuation", {STATE_LIGHT, 0, STATE_ATTENUATION}, SWIZZLE_ZZZZ}, 94}; 95 96static const struct gl_builtin_uniform_element gl_LightModel_elements[] = { 97 {"ambient", {STATE_LIGHTMODEL_AMBIENT, 0}, SWIZZLE_XYZW}, 98}; 99 100static const struct gl_builtin_uniform_element gl_FrontLightModelProduct_elements[] = { 101 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 0}, SWIZZLE_XYZW}, 102}; 103 104static const struct gl_builtin_uniform_element gl_BackLightModelProduct_elements[] = { 105 {"sceneColor", {STATE_LIGHTMODEL_SCENECOLOR, 1}, SWIZZLE_XYZW}, 106}; 107 108static const struct gl_builtin_uniform_element gl_FrontLightProduct_elements[] = { 109 {"ambient", {STATE_LIGHTPROD, 0, 0, STATE_AMBIENT}, SWIZZLE_XYZW}, 110 {"diffuse", {STATE_LIGHTPROD, 0, 0, STATE_DIFFUSE}, SWIZZLE_XYZW}, 111 {"specular", {STATE_LIGHTPROD, 0, 0, STATE_SPECULAR}, SWIZZLE_XYZW}, 112}; 113 114static const struct gl_builtin_uniform_element gl_BackLightProduct_elements[] = { 115 {"ambient", {STATE_LIGHTPROD, 0, 1, STATE_AMBIENT}, SWIZZLE_XYZW}, 116 {"diffuse", {STATE_LIGHTPROD, 0, 1, STATE_DIFFUSE}, SWIZZLE_XYZW}, 117 {"specular", {STATE_LIGHTPROD, 0, 1, STATE_SPECULAR}, SWIZZLE_XYZW}, 118}; 119 120static const struct gl_builtin_uniform_element gl_TextureEnvColor_elements[] = { 121 {NULL, {STATE_TEXENV_COLOR, 0}, SWIZZLE_XYZW}, 122}; 123 124static const struct gl_builtin_uniform_element gl_EyePlaneS_elements[] = { 125 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_S}, SWIZZLE_XYZW}, 126}; 127 128static const struct gl_builtin_uniform_element gl_EyePlaneT_elements[] = { 129 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_T}, SWIZZLE_XYZW}, 130}; 131 132static const struct gl_builtin_uniform_element gl_EyePlaneR_elements[] = { 133 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_R}, SWIZZLE_XYZW}, 134}; 135 136static const struct gl_builtin_uniform_element gl_EyePlaneQ_elements[] = { 137 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_EYE_Q}, SWIZZLE_XYZW}, 138}; 139 140static const struct gl_builtin_uniform_element gl_ObjectPlaneS_elements[] = { 141 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_S}, SWIZZLE_XYZW}, 142}; 143 144static const struct gl_builtin_uniform_element gl_ObjectPlaneT_elements[] = { 145 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_T}, SWIZZLE_XYZW}, 146}; 147 148static const struct gl_builtin_uniform_element gl_ObjectPlaneR_elements[] = { 149 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_R}, SWIZZLE_XYZW}, 150}; 151 152static const struct gl_builtin_uniform_element gl_ObjectPlaneQ_elements[] = { 153 {NULL, {STATE_TEXGEN, 0, STATE_TEXGEN_OBJECT_Q}, SWIZZLE_XYZW}, 154}; 155 156static const struct gl_builtin_uniform_element gl_Fog_elements[] = { 157 {"color", {STATE_FOG_COLOR}, SWIZZLE_XYZW}, 158 {"density", {STATE_FOG_PARAMS}, SWIZZLE_XXXX}, 159 {"start", {STATE_FOG_PARAMS}, SWIZZLE_YYYY}, 160 {"end", {STATE_FOG_PARAMS}, SWIZZLE_ZZZZ}, 161 {"scale", {STATE_FOG_PARAMS}, SWIZZLE_WWWW}, 162}; 163 164static const struct gl_builtin_uniform_element gl_NormalScale_elements[] = { 165 {NULL, {STATE_NORMAL_SCALE}, SWIZZLE_XXXX}, 166}; 167 168static const struct gl_builtin_uniform_element gl_FogParamsOptimizedMESA_elements[] = { 169 {NULL, {STATE_INTERNAL, STATE_FOG_PARAMS_OPTIMIZED}, SWIZZLE_XYZW}, 170}; 171 172static const struct gl_builtin_uniform_element gl_CurrentAttribVertMESA_elements[] = { 173 {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB, 0}, SWIZZLE_XYZW}, 174}; 175 176static const struct gl_builtin_uniform_element gl_CurrentAttribFragMESA_elements[] = { 177 {NULL, {STATE_INTERNAL, STATE_CURRENT_ATTRIB_MAYBE_VP_CLAMPED, 0}, SWIZZLE_XYZW}, 178}; 179 180#define MATRIX(name, statevar, modifier) \ 181 static const struct gl_builtin_uniform_element name ## _elements[] = { \ 182 { NULL, { statevar, 0, 0, 0, modifier}, SWIZZLE_XYZW }, \ 183 { NULL, { statevar, 0, 1, 1, modifier}, SWIZZLE_XYZW }, \ 184 { NULL, { statevar, 0, 2, 2, modifier}, SWIZZLE_XYZW }, \ 185 { NULL, { statevar, 0, 3, 3, modifier}, SWIZZLE_XYZW }, \ 186 } 187 188MATRIX(gl_ModelViewMatrix, 189 STATE_MODELVIEW_MATRIX, STATE_MATRIX_TRANSPOSE); 190MATRIX(gl_ModelViewMatrixInverse, 191 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVTRANS); 192MATRIX(gl_ModelViewMatrixTranspose, 193 STATE_MODELVIEW_MATRIX, 0); 194MATRIX(gl_ModelViewMatrixInverseTranspose, 195 STATE_MODELVIEW_MATRIX, STATE_MATRIX_INVERSE); 196 197MATRIX(gl_ProjectionMatrix, 198 STATE_PROJECTION_MATRIX, STATE_MATRIX_TRANSPOSE); 199MATRIX(gl_ProjectionMatrixInverse, 200 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVTRANS); 201MATRIX(gl_ProjectionMatrixTranspose, 202 STATE_PROJECTION_MATRIX, 0); 203MATRIX(gl_ProjectionMatrixInverseTranspose, 204 STATE_PROJECTION_MATRIX, STATE_MATRIX_INVERSE); 205 206MATRIX(gl_ModelViewProjectionMatrix, 207 STATE_MVP_MATRIX, STATE_MATRIX_TRANSPOSE); 208MATRIX(gl_ModelViewProjectionMatrixInverse, 209 STATE_MVP_MATRIX, STATE_MATRIX_INVTRANS); 210MATRIX(gl_ModelViewProjectionMatrixTranspose, 211 STATE_MVP_MATRIX, 0); 212MATRIX(gl_ModelViewProjectionMatrixInverseTranspose, 213 STATE_MVP_MATRIX, STATE_MATRIX_INVERSE); 214 215MATRIX(gl_TextureMatrix, 216 STATE_TEXTURE_MATRIX, STATE_MATRIX_TRANSPOSE); 217MATRIX(gl_TextureMatrixInverse, 218 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVTRANS); 219MATRIX(gl_TextureMatrixTranspose, 220 STATE_TEXTURE_MATRIX, 0); 221MATRIX(gl_TextureMatrixInverseTranspose, 222 STATE_TEXTURE_MATRIX, STATE_MATRIX_INVERSE); 223 224static const struct gl_builtin_uniform_element gl_NormalMatrix_elements[] = { 225 { NULL, { STATE_MODELVIEW_MATRIX, 0, 0, 0, STATE_MATRIX_INVERSE}, 226 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, 227 { NULL, { STATE_MODELVIEW_MATRIX, 0, 1, 1, STATE_MATRIX_INVERSE}, 228 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, 229 { NULL, { STATE_MODELVIEW_MATRIX, 0, 2, 2, STATE_MATRIX_INVERSE}, 230 MAKE_SWIZZLE4(SWIZZLE_X, SWIZZLE_Y, SWIZZLE_Z, SWIZZLE_Z) }, 231}; 232 233#undef MATRIX 234 235#define STATEVAR(name) {#name, name ## _elements, ARRAY_SIZE(name ## _elements)} 236 237static const struct gl_builtin_uniform_desc _mesa_builtin_uniform_desc[] = { 238 STATEVAR(gl_NumSamples), 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_FogParamsOptimizedMESA), 285 STATEVAR(gl_CurrentAttribVertMESA), 286 STATEVAR(gl_CurrentAttribFragMESA), 287 288 {NULL, NULL, 0} 289}; 290 291 292namespace { 293 294/** 295 * Data structure that accumulates fields for the gl_PerVertex interface 296 * block. 297 */ 298class per_vertex_accumulator 299{ 300public: 301 per_vertex_accumulator(); 302 void add_field(int slot, const glsl_type *type, const char *name); 303 const glsl_type *construct_interface_instance() const; 304 305private: 306 glsl_struct_field fields[11]; 307 unsigned num_fields; 308}; 309 310 311per_vertex_accumulator::per_vertex_accumulator() 312 : fields(), 313 num_fields(0) 314{ 315} 316 317 318void 319per_vertex_accumulator::add_field(int slot, const glsl_type *type, 320 const char *name) 321{ 322 assert(this->num_fields < ARRAY_SIZE(this->fields)); 323 this->fields[this->num_fields].type = type; 324 this->fields[this->num_fields].name = name; 325 this->fields[this->num_fields].matrix_layout = GLSL_MATRIX_LAYOUT_INHERITED; 326 this->fields[this->num_fields].location = slot; 327 this->fields[this->num_fields].offset = -1; 328 this->fields[this->num_fields].interpolation = INTERP_MODE_NONE; 329 this->fields[this->num_fields].centroid = 0; 330 this->fields[this->num_fields].sample = 0; 331 this->fields[this->num_fields].patch = 0; 332 this->fields[this->num_fields].precision = GLSL_PRECISION_NONE; 333 this->fields[this->num_fields].memory_read_only = 0; 334 this->fields[this->num_fields].memory_write_only = 0; 335 this->fields[this->num_fields].memory_coherent = 0; 336 this->fields[this->num_fields].memory_volatile = 0; 337 this->fields[this->num_fields].memory_restrict = 0; 338 this->fields[this->num_fields].image_format = 0; 339 this->fields[this->num_fields].explicit_xfb_buffer = 0; 340 this->fields[this->num_fields].xfb_buffer = -1; 341 this->fields[this->num_fields].xfb_stride = -1; 342 this->num_fields++; 343} 344 345 346const glsl_type * 347per_vertex_accumulator::construct_interface_instance() const 348{ 349 return glsl_type::get_interface_instance(this->fields, this->num_fields, 350 GLSL_INTERFACE_PACKING_STD140, 351 false, 352 "gl_PerVertex"); 353} 354 355 356class builtin_variable_generator 357{ 358public: 359 builtin_variable_generator(exec_list *instructions, 360 struct _mesa_glsl_parse_state *state); 361 void generate_constants(); 362 void generate_uniforms(); 363 void generate_special_vars(); 364 void generate_vs_special_vars(); 365 void generate_tcs_special_vars(); 366 void generate_tes_special_vars(); 367 void generate_gs_special_vars(); 368 void generate_fs_special_vars(); 369 void generate_cs_special_vars(); 370 void generate_varyings(); 371 372private: 373 const glsl_type *array(const glsl_type *base, unsigned elements) 374 { 375 return glsl_type::get_array_instance(base, elements); 376 } 377 378 const glsl_type *type(const char *name) 379 { 380 return symtab->get_type(name); 381 } 382 383 ir_variable *add_input(int slot, const glsl_type *type, const char *name) 384 { 385 return add_variable(name, type, ir_var_shader_in, slot); 386 } 387 388 ir_variable *add_output(int slot, const glsl_type *type, const char *name) 389 { 390 return add_variable(name, type, ir_var_shader_out, slot); 391 } 392 393 ir_variable *add_index_output(int slot, int index, const glsl_type *type, const char *name) 394 { 395 return add_index_variable(name, type, ir_var_shader_out, slot, index); 396 } 397 398 ir_variable *add_system_value(int slot, const glsl_type *type, 399 const char *name) 400 { 401 return add_variable(name, type, ir_var_system_value, slot); 402 } 403 404 ir_variable *add_variable(const char *name, const glsl_type *type, 405 enum ir_variable_mode mode, int slot); 406 ir_variable *add_index_variable(const char *name, const glsl_type *type, 407 enum ir_variable_mode mode, int slot, int index); 408 ir_variable *add_uniform(const glsl_type *type, const char *name); 409 ir_variable *add_const(const char *name, int value); 410 ir_variable *add_const_ivec3(const char *name, int x, int y, int z); 411 void add_varying(int slot, const glsl_type *type, const char *name); 412 413 exec_list * const instructions; 414 struct _mesa_glsl_parse_state * const state; 415 glsl_symbol_table * const symtab; 416 417 /** 418 * True if compatibility-profile-only variables should be included. (In 419 * desktop GL, these are always included when the GLSL version is 1.30 and 420 * or below). 421 */ 422 const bool compatibility; 423 424 const glsl_type * const bool_t; 425 const glsl_type * const int_t; 426 const glsl_type * const uint_t; 427 const glsl_type * const uint64_t; 428 const glsl_type * const float_t; 429 const glsl_type * const vec2_t; 430 const glsl_type * const vec3_t; 431 const glsl_type * const vec4_t; 432 const glsl_type * const uvec3_t; 433 const glsl_type * const mat3_t; 434 const glsl_type * const mat4_t; 435 436 per_vertex_accumulator per_vertex_in; 437 per_vertex_accumulator per_vertex_out; 438}; 439 440 441builtin_variable_generator::builtin_variable_generator( 442 exec_list *instructions, struct _mesa_glsl_parse_state *state) 443 : instructions(instructions), state(state), symtab(state->symbols), 444 compatibility(state->compat_shader || state->ARB_compatibility_enable), 445 bool_t(glsl_type::bool_type), int_t(glsl_type::int_type), 446 uint_t(glsl_type::uint_type), 447 uint64_t(glsl_type::uint64_t_type), 448 float_t(glsl_type::float_type), vec2_t(glsl_type::vec2_type), 449 vec3_t(glsl_type::vec3_type), vec4_t(glsl_type::vec4_type), 450 uvec3_t(glsl_type::uvec3_type), 451 mat3_t(glsl_type::mat3_type), mat4_t(glsl_type::mat4_type) 452{ 453} 454 455ir_variable * 456builtin_variable_generator::add_index_variable(const char *name, 457 const glsl_type *type, 458 enum ir_variable_mode mode, int slot, int index) 459{ 460 ir_variable *var = new(symtab) ir_variable(type, name, mode); 461 var->data.how_declared = ir_var_declared_implicitly; 462 463 switch (var->data.mode) { 464 case ir_var_auto: 465 case ir_var_shader_in: 466 case ir_var_uniform: 467 case ir_var_system_value: 468 var->data.read_only = true; 469 break; 470 case ir_var_shader_out: 471 case ir_var_shader_storage: 472 break; 473 default: 474 /* The only variables that are added using this function should be 475 * uniforms, shader storage, shader inputs, and shader outputs, constants 476 * (which use ir_var_auto), and system values. 477 */ 478 assert(0); 479 break; 480 } 481 482 var->data.location = slot; 483 var->data.explicit_location = (slot >= 0); 484 var->data.explicit_index = 1; 485 var->data.index = index; 486 487 /* Once the variable is created an initialized, add it to the symbol table 488 * and add the declaration to the IR stream. 489 */ 490 instructions->push_tail(var); 491 492 symtab->add_variable(var); 493 return var; 494} 495 496ir_variable * 497builtin_variable_generator::add_variable(const char *name, 498 const glsl_type *type, 499 enum ir_variable_mode mode, int slot) 500{ 501 ir_variable *var = new(symtab) ir_variable(type, name, mode); 502 var->data.how_declared = ir_var_declared_implicitly; 503 504 switch (var->data.mode) { 505 case ir_var_auto: 506 case ir_var_shader_in: 507 case ir_var_uniform: 508 case ir_var_system_value: 509 var->data.read_only = true; 510 break; 511 case ir_var_shader_out: 512 case ir_var_shader_storage: 513 break; 514 default: 515 /* The only variables that are added using this function should be 516 * uniforms, shader storage, shader inputs, and shader outputs, constants 517 * (which use ir_var_auto), and system values. 518 */ 519 assert(0); 520 break; 521 } 522 523 var->data.location = slot; 524 var->data.explicit_location = (slot >= 0); 525 var->data.explicit_index = 0; 526 527 /* Once the variable is created an initialized, add it to the symbol table 528 * and add the declaration to the IR stream. 529 */ 530 instructions->push_tail(var); 531 532 symtab->add_variable(var); 533 return var; 534} 535 536extern "C" const struct gl_builtin_uniform_desc * 537_mesa_glsl_get_builtin_uniform_desc(const char *name) 538{ 539 for (unsigned i = 0; _mesa_builtin_uniform_desc[i].name != NULL; i++) { 540 if (strcmp(_mesa_builtin_uniform_desc[i].name, name) == 0) { 541 return &_mesa_builtin_uniform_desc[i]; 542 } 543 } 544 return NULL; 545} 546 547ir_variable * 548builtin_variable_generator::add_uniform(const glsl_type *type, 549 const char *name) 550{ 551 ir_variable *const uni = add_variable(name, type, ir_var_uniform, -1); 552 553 const struct gl_builtin_uniform_desc* const statevar = 554 _mesa_glsl_get_builtin_uniform_desc(name); 555 assert(statevar != NULL); 556 557 const unsigned array_count = type->is_array() ? type->length : 1; 558 559 ir_state_slot *slots = 560 uni->allocate_state_slots(array_count * statevar->num_elements); 561 562 for (unsigned a = 0; a < array_count; a++) { 563 for (unsigned j = 0; j < statevar->num_elements; j++) { 564 const struct gl_builtin_uniform_element *element = 565 &statevar->elements[j]; 566 567 memcpy(slots->tokens, element->tokens, sizeof(element->tokens)); 568 if (type->is_array()) { 569 if (strcmp(name, "gl_CurrentAttribVertMESA") == 0 || 570 strcmp(name, "gl_CurrentAttribFragMESA") == 0) { 571 slots->tokens[2] = a; 572 } else { 573 slots->tokens[1] = a; 574 } 575 } 576 577 slots->swizzle = element->swizzle; 578 slots++; 579 } 580 } 581 582 return uni; 583} 584 585 586ir_variable * 587builtin_variable_generator::add_const(const char *name, int value) 588{ 589 ir_variable *const var = add_variable(name, glsl_type::int_type, 590 ir_var_auto, -1); 591 var->constant_value = new(var) ir_constant(value); 592 var->constant_initializer = new(var) ir_constant(value); 593 var->data.has_initializer = true; 594 return var; 595} 596 597 598ir_variable * 599builtin_variable_generator::add_const_ivec3(const char *name, int x, int y, 600 int z) 601{ 602 ir_variable *const var = add_variable(name, glsl_type::ivec3_type, 603 ir_var_auto, -1); 604 ir_constant_data data; 605 memset(&data, 0, sizeof(data)); 606 data.i[0] = x; 607 data.i[1] = y; 608 data.i[2] = z; 609 var->constant_value = new(var) ir_constant(glsl_type::ivec3_type, &data); 610 var->constant_initializer = 611 new(var) ir_constant(glsl_type::ivec3_type, &data); 612 var->data.has_initializer = true; 613 return var; 614} 615 616 617void 618builtin_variable_generator::generate_constants() 619{ 620 add_const("gl_MaxVertexAttribs", state->Const.MaxVertexAttribs); 621 add_const("gl_MaxVertexTextureImageUnits", 622 state->Const.MaxVertexTextureImageUnits); 623 add_const("gl_MaxCombinedTextureImageUnits", 624 state->Const.MaxCombinedTextureImageUnits); 625 add_const("gl_MaxTextureImageUnits", state->Const.MaxTextureImageUnits); 626 add_const("gl_MaxDrawBuffers", state->Const.MaxDrawBuffers); 627 628 /* Max uniforms/varyings: GLSL ES counts these in units of vectors; desktop 629 * GL counts them in units of "components" or "floats" and also in units 630 * of vectors since GL 4.1 631 */ 632 if (!state->es_shader) { 633 add_const("gl_MaxFragmentUniformComponents", 634 state->Const.MaxFragmentUniformComponents); 635 add_const("gl_MaxVertexUniformComponents", 636 state->Const.MaxVertexUniformComponents); 637 } 638 639 if (state->is_version(410, 100)) { 640 add_const("gl_MaxVertexUniformVectors", 641 state->Const.MaxVertexUniformComponents / 4); 642 add_const("gl_MaxFragmentUniformVectors", 643 state->Const.MaxFragmentUniformComponents / 4); 644 645 /* In GLSL ES 3.00, gl_MaxVaryingVectors was split out to separate 646 * vertex and fragment shader constants. 647 */ 648 if (state->is_version(0, 300)) { 649 add_const("gl_MaxVertexOutputVectors", 650 state->ctx->Const.Program[MESA_SHADER_VERTEX].MaxOutputComponents / 4); 651 add_const("gl_MaxFragmentInputVectors", 652 state->ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxInputComponents / 4); 653 } else { 654 add_const("gl_MaxVaryingVectors", 655 state->ctx->Const.MaxVarying); 656 } 657 658 /* EXT_blend_func_extended brings a built in constant 659 * for determining number of dual source draw buffers 660 */ 661 if (state->EXT_blend_func_extended_enable) { 662 add_const("gl_MaxDualSourceDrawBuffersEXT", 663 state->Const.MaxDualSourceDrawBuffers); 664 } 665 } else { 666 /* Note: gl_MaxVaryingFloats was deprecated in GLSL 1.30+, but not 667 * removed 668 */ 669 add_const("gl_MaxVaryingFloats", state->ctx->Const.MaxVarying * 4); 670 } 671 672 /* Texel offsets were introduced in ARB_shading_language_420pack (which 673 * requires desktop GLSL version 130), and adopted into desktop GLSL 674 * version 4.20 and GLSL ES version 3.00. 675 */ 676 if ((state->is_version(130, 0) && 677 state->ARB_shading_language_420pack_enable) || 678 state->is_version(420, 300)) { 679 add_const("gl_MinProgramTexelOffset", 680 state->Const.MinProgramTexelOffset); 681 add_const("gl_MaxProgramTexelOffset", 682 state->Const.MaxProgramTexelOffset); 683 } 684 685 if (state->has_clip_distance()) { 686 add_const("gl_MaxClipDistances", state->Const.MaxClipPlanes); 687 } 688 if (state->is_version(130, 0)) { 689 add_const("gl_MaxVaryingComponents", state->ctx->Const.MaxVarying * 4); 690 } 691 if (state->has_cull_distance()) { 692 add_const("gl_MaxCullDistances", state->Const.MaxClipPlanes); 693 add_const("gl_MaxCombinedClipAndCullDistances", 694 state->Const.MaxClipPlanes); 695 } 696 697 if (state->has_geometry_shader()) { 698 add_const("gl_MaxVertexOutputComponents", 699 state->Const.MaxVertexOutputComponents); 700 add_const("gl_MaxGeometryInputComponents", 701 state->Const.MaxGeometryInputComponents); 702 add_const("gl_MaxGeometryOutputComponents", 703 state->Const.MaxGeometryOutputComponents); 704 add_const("gl_MaxFragmentInputComponents", 705 state->Const.MaxFragmentInputComponents); 706 add_const("gl_MaxGeometryTextureImageUnits", 707 state->Const.MaxGeometryTextureImageUnits); 708 add_const("gl_MaxGeometryOutputVertices", 709 state->Const.MaxGeometryOutputVertices); 710 add_const("gl_MaxGeometryTotalOutputComponents", 711 state->Const.MaxGeometryTotalOutputComponents); 712 add_const("gl_MaxGeometryUniformComponents", 713 state->Const.MaxGeometryUniformComponents); 714 715 /* Note: the GLSL 1.50-4.40 specs require 716 * gl_MaxGeometryVaryingComponents to be present, and to be at least 64. 717 * But they do not define what it means (and there does not appear to be 718 * any corresponding constant in the GL specs). However, 719 * ARB_geometry_shader4 defines MAX_GEOMETRY_VARYING_COMPONENTS_ARB to 720 * be the maximum number of components available for use as geometry 721 * outputs. So we assume this is a synonym for 722 * gl_MaxGeometryOutputComponents. 723 */ 724 add_const("gl_MaxGeometryVaryingComponents", 725 state->Const.MaxGeometryOutputComponents); 726 } 727 728 if (compatibility) { 729 /* Note: gl_MaxLights stopped being listed as an explicit constant in 730 * GLSL 1.30, however it continues to be referred to (as a minimum size 731 * for compatibility-mode uniforms) all the way up through GLSL 4.30, so 732 * this seems like it was probably an oversight. 733 */ 734 add_const("gl_MaxLights", state->Const.MaxLights); 735 736 add_const("gl_MaxClipPlanes", state->Const.MaxClipPlanes); 737 738 /* Note: gl_MaxTextureUnits wasn't made compatibility-only until GLSL 739 * 1.50, however this seems like it was probably an oversight. 740 */ 741 add_const("gl_MaxTextureUnits", state->Const.MaxTextureUnits); 742 743 /* Note: gl_MaxTextureCoords was left out of GLSL 1.40, but it was 744 * re-introduced in GLSL 1.50, so this seems like it was probably an 745 * oversight. 746 */ 747 add_const("gl_MaxTextureCoords", state->Const.MaxTextureCoords); 748 } 749 750 if (state->has_atomic_counters()) { 751 add_const("gl_MaxVertexAtomicCounters", 752 state->Const.MaxVertexAtomicCounters); 753 add_const("gl_MaxFragmentAtomicCounters", 754 state->Const.MaxFragmentAtomicCounters); 755 add_const("gl_MaxCombinedAtomicCounters", 756 state->Const.MaxCombinedAtomicCounters); 757 add_const("gl_MaxAtomicCounterBindings", 758 state->Const.MaxAtomicBufferBindings); 759 760 if (state->has_geometry_shader()) { 761 add_const("gl_MaxGeometryAtomicCounters", 762 state->Const.MaxGeometryAtomicCounters); 763 } 764 if (state->is_version(110, 320)) { 765 add_const("gl_MaxTessControlAtomicCounters", 766 state->Const.MaxTessControlAtomicCounters); 767 add_const("gl_MaxTessEvaluationAtomicCounters", 768 state->Const.MaxTessEvaluationAtomicCounters); 769 } 770 } 771 772 if (state->is_version(420, 310)) { 773 add_const("gl_MaxVertexAtomicCounterBuffers", 774 state->Const.MaxVertexAtomicCounterBuffers); 775 add_const("gl_MaxFragmentAtomicCounterBuffers", 776 state->Const.MaxFragmentAtomicCounterBuffers); 777 add_const("gl_MaxCombinedAtomicCounterBuffers", 778 state->Const.MaxCombinedAtomicCounterBuffers); 779 add_const("gl_MaxAtomicCounterBufferSize", 780 state->Const.MaxAtomicCounterBufferSize); 781 782 if (state->has_geometry_shader()) { 783 add_const("gl_MaxGeometryAtomicCounterBuffers", 784 state->Const.MaxGeometryAtomicCounterBuffers); 785 } 786 if (state->is_version(110, 320)) { 787 add_const("gl_MaxTessControlAtomicCounterBuffers", 788 state->Const.MaxTessControlAtomicCounterBuffers); 789 add_const("gl_MaxTessEvaluationAtomicCounterBuffers", 790 state->Const.MaxTessEvaluationAtomicCounterBuffers); 791 } 792 } 793 794 if (state->is_version(430, 310) || state->ARB_compute_shader_enable) { 795 add_const("gl_MaxComputeAtomicCounterBuffers", 796 state->Const.MaxComputeAtomicCounterBuffers); 797 add_const("gl_MaxComputeAtomicCounters", 798 state->Const.MaxComputeAtomicCounters); 799 add_const("gl_MaxComputeImageUniforms", 800 state->Const.MaxComputeImageUniforms); 801 add_const("gl_MaxComputeTextureImageUnits", 802 state->Const.MaxComputeTextureImageUnits); 803 add_const("gl_MaxComputeUniformComponents", 804 state->Const.MaxComputeUniformComponents); 805 806 add_const_ivec3("gl_MaxComputeWorkGroupCount", 807 state->Const.MaxComputeWorkGroupCount[0], 808 state->Const.MaxComputeWorkGroupCount[1], 809 state->Const.MaxComputeWorkGroupCount[2]); 810 add_const_ivec3("gl_MaxComputeWorkGroupSize", 811 state->Const.MaxComputeWorkGroupSize[0], 812 state->Const.MaxComputeWorkGroupSize[1], 813 state->Const.MaxComputeWorkGroupSize[2]); 814 815 /* From the GLSL 4.40 spec, section 7.1 (Built-In Language Variables): 816 * 817 * The built-in constant gl_WorkGroupSize is a compute-shader 818 * constant containing the local work-group size of the shader. The 819 * size of the work group in the X, Y, and Z dimensions is stored in 820 * the x, y, and z components. The constants values in 821 * gl_WorkGroupSize will match those specified in the required 822 * local_size_x, local_size_y, and local_size_z layout qualifiers 823 * for the current shader. This is a constant so that it can be 824 * used to size arrays of memory that can be shared within the local 825 * work group. It is a compile-time error to use gl_WorkGroupSize 826 * in a shader that does not declare a fixed local group size, or 827 * before that shader has declared a fixed local group size, using 828 * local_size_x, local_size_y, and local_size_z. 829 * 830 * To prevent the shader from trying to refer to gl_WorkGroupSize before 831 * the layout declaration, we don't define it here. Intead we define it 832 * in ast_cs_input_layout::hir(). 833 */ 834 } 835 836 if (state->has_enhanced_layouts()) { 837 add_const("gl_MaxTransformFeedbackBuffers", 838 state->Const.MaxTransformFeedbackBuffers); 839 add_const("gl_MaxTransformFeedbackInterleavedComponents", 840 state->Const.MaxTransformFeedbackInterleavedComponents); 841 } 842 843 if (state->has_shader_image_load_store()) { 844 add_const("gl_MaxImageUnits", 845 state->Const.MaxImageUnits); 846 add_const("gl_MaxVertexImageUniforms", 847 state->Const.MaxVertexImageUniforms); 848 add_const("gl_MaxFragmentImageUniforms", 849 state->Const.MaxFragmentImageUniforms); 850 add_const("gl_MaxCombinedImageUniforms", 851 state->Const.MaxCombinedImageUniforms); 852 853 if (state->has_geometry_shader()) { 854 add_const("gl_MaxGeometryImageUniforms", 855 state->Const.MaxGeometryImageUniforms); 856 } 857 858 if (!state->es_shader) { 859 add_const("gl_MaxCombinedImageUnitsAndFragmentOutputs", 860 state->Const.MaxCombinedShaderOutputResources); 861 add_const("gl_MaxImageSamples", 862 state->Const.MaxImageSamples); 863 } 864 865 if (state->has_tessellation_shader()) { 866 add_const("gl_MaxTessControlImageUniforms", 867 state->Const.MaxTessControlImageUniforms); 868 add_const("gl_MaxTessEvaluationImageUniforms", 869 state->Const.MaxTessEvaluationImageUniforms); 870 } 871 } 872 873 if (state->is_version(440, 310) || 874 state->ARB_ES3_1_compatibility_enable) { 875 add_const("gl_MaxCombinedShaderOutputResources", 876 state->Const.MaxCombinedShaderOutputResources); 877 } 878 879 if (state->is_version(410, 0) || 880 state->ARB_viewport_array_enable || 881 state->OES_viewport_array_enable) 882 add_const("gl_MaxViewports", state->Const.MaxViewports); 883 884 if (state->has_tessellation_shader()) { 885 add_const("gl_MaxPatchVertices", state->Const.MaxPatchVertices); 886 add_const("gl_MaxTessGenLevel", state->Const.MaxTessGenLevel); 887 add_const("gl_MaxTessControlInputComponents", state->Const.MaxTessControlInputComponents); 888 add_const("gl_MaxTessControlOutputComponents", state->Const.MaxTessControlOutputComponents); 889 add_const("gl_MaxTessControlTextureImageUnits", state->Const.MaxTessControlTextureImageUnits); 890 add_const("gl_MaxTessEvaluationInputComponents", state->Const.MaxTessEvaluationInputComponents); 891 add_const("gl_MaxTessEvaluationOutputComponents", state->Const.MaxTessEvaluationOutputComponents); 892 add_const("gl_MaxTessEvaluationTextureImageUnits", state->Const.MaxTessEvaluationTextureImageUnits); 893 add_const("gl_MaxTessPatchComponents", state->Const.MaxTessPatchComponents); 894 add_const("gl_MaxTessControlTotalOutputComponents", state->Const.MaxTessControlTotalOutputComponents); 895 add_const("gl_MaxTessControlUniformComponents", state->Const.MaxTessControlUniformComponents); 896 add_const("gl_MaxTessEvaluationUniformComponents", state->Const.MaxTessEvaluationUniformComponents); 897 } 898 899 if (state->is_version(450, 320) || 900 state->OES_sample_variables_enable || 901 state->ARB_ES3_1_compatibility_enable) 902 add_const("gl_MaxSamples", state->Const.MaxSamples); 903} 904 905 906/** 907 * Generate uniform variables (which exist in all types of shaders). 908 */ 909void 910builtin_variable_generator::generate_uniforms() 911{ 912 if (state->is_version(400, 320) || 913 state->ARB_sample_shading_enable || 914 state->OES_sample_variables_enable) 915 add_uniform(int_t, "gl_NumSamples"); 916 add_uniform(type("gl_DepthRangeParameters"), "gl_DepthRange"); 917 add_uniform(array(vec4_t, VERT_ATTRIB_MAX), "gl_CurrentAttribVertMESA"); 918 add_uniform(array(vec4_t, VARYING_SLOT_MAX), "gl_CurrentAttribFragMESA"); 919 920 if (compatibility) { 921 add_uniform(mat4_t, "gl_ModelViewMatrix"); 922 add_uniform(mat4_t, "gl_ProjectionMatrix"); 923 add_uniform(mat4_t, "gl_ModelViewProjectionMatrix"); 924 add_uniform(mat3_t, "gl_NormalMatrix"); 925 add_uniform(mat4_t, "gl_ModelViewMatrixInverse"); 926 add_uniform(mat4_t, "gl_ProjectionMatrixInverse"); 927 add_uniform(mat4_t, "gl_ModelViewProjectionMatrixInverse"); 928 add_uniform(mat4_t, "gl_ModelViewMatrixTranspose"); 929 add_uniform(mat4_t, "gl_ProjectionMatrixTranspose"); 930 add_uniform(mat4_t, "gl_ModelViewProjectionMatrixTranspose"); 931 add_uniform(mat4_t, "gl_ModelViewMatrixInverseTranspose"); 932 add_uniform(mat4_t, "gl_ProjectionMatrixInverseTranspose"); 933 add_uniform(mat4_t, "gl_ModelViewProjectionMatrixInverseTranspose"); 934 add_uniform(float_t, "gl_NormalScale"); 935 add_uniform(type("gl_LightModelParameters"), "gl_LightModel"); 936 add_uniform(vec4_t, "gl_FogParamsOptimizedMESA"); 937 938 const glsl_type *const mat4_array_type = 939 array(mat4_t, state->Const.MaxTextureCoords); 940 add_uniform(mat4_array_type, "gl_TextureMatrix"); 941 add_uniform(mat4_array_type, "gl_TextureMatrixInverse"); 942 add_uniform(mat4_array_type, "gl_TextureMatrixTranspose"); 943 add_uniform(mat4_array_type, "gl_TextureMatrixInverseTranspose"); 944 945 add_uniform(array(vec4_t, state->Const.MaxClipPlanes), "gl_ClipPlane"); 946 add_uniform(type("gl_PointParameters"), "gl_Point"); 947 948 const glsl_type *const material_parameters_type = 949 type("gl_MaterialParameters"); 950 add_uniform(material_parameters_type, "gl_FrontMaterial"); 951 add_uniform(material_parameters_type, "gl_BackMaterial"); 952 953 add_uniform(array(type("gl_LightSourceParameters"), 954 state->Const.MaxLights), 955 "gl_LightSource"); 956 957 const glsl_type *const light_model_products_type = 958 type("gl_LightModelProducts"); 959 add_uniform(light_model_products_type, "gl_FrontLightModelProduct"); 960 add_uniform(light_model_products_type, "gl_BackLightModelProduct"); 961 962 const glsl_type *const light_products_type = 963 array(type("gl_LightProducts"), state->Const.MaxLights); 964 add_uniform(light_products_type, "gl_FrontLightProduct"); 965 add_uniform(light_products_type, "gl_BackLightProduct"); 966 967 add_uniform(array(vec4_t, state->Const.MaxTextureUnits), 968 "gl_TextureEnvColor"); 969 970 const glsl_type *const texcoords_vec4 = 971 array(vec4_t, state->Const.MaxTextureCoords); 972 add_uniform(texcoords_vec4, "gl_EyePlaneS"); 973 add_uniform(texcoords_vec4, "gl_EyePlaneT"); 974 add_uniform(texcoords_vec4, "gl_EyePlaneR"); 975 add_uniform(texcoords_vec4, "gl_EyePlaneQ"); 976 add_uniform(texcoords_vec4, "gl_ObjectPlaneS"); 977 add_uniform(texcoords_vec4, "gl_ObjectPlaneT"); 978 add_uniform(texcoords_vec4, "gl_ObjectPlaneR"); 979 add_uniform(texcoords_vec4, "gl_ObjectPlaneQ"); 980 981 add_uniform(type("gl_FogParameters"), "gl_Fog"); 982 } 983} 984 985 986/** 987 * Generate special variables which exist in all shaders. 988 */ 989void 990builtin_variable_generator::generate_special_vars() 991{ 992 if (state->ARB_shader_ballot_enable) { 993 add_system_value(SYSTEM_VALUE_SUBGROUP_SIZE, uint_t, "gl_SubGroupSizeARB"); 994 add_system_value(SYSTEM_VALUE_SUBGROUP_INVOCATION, uint_t, "gl_SubGroupInvocationARB"); 995 add_system_value(SYSTEM_VALUE_SUBGROUP_EQ_MASK, uint64_t, "gl_SubGroupEqMaskARB"); 996 add_system_value(SYSTEM_VALUE_SUBGROUP_GE_MASK, uint64_t, "gl_SubGroupGeMaskARB"); 997 add_system_value(SYSTEM_VALUE_SUBGROUP_GT_MASK, uint64_t, "gl_SubGroupGtMaskARB"); 998 add_system_value(SYSTEM_VALUE_SUBGROUP_LE_MASK, uint64_t, "gl_SubGroupLeMaskARB"); 999 add_system_value(SYSTEM_VALUE_SUBGROUP_LT_MASK, uint64_t, "gl_SubGroupLtMaskARB"); 1000 } 1001} 1002 1003 1004/** 1005 * Generate variables which only exist in vertex shaders. 1006 */ 1007void 1008builtin_variable_generator::generate_vs_special_vars() 1009{ 1010 ir_variable *var; 1011 1012 if (state->is_version(130, 300)) 1013 add_system_value(SYSTEM_VALUE_VERTEX_ID, int_t, "gl_VertexID"); 1014 if (state->is_version(460, 0)) { 1015 add_system_value(SYSTEM_VALUE_BASE_VERTEX, int_t, "gl_BaseVertex"); 1016 add_system_value(SYSTEM_VALUE_BASE_INSTANCE, int_t, "gl_BaseInstance"); 1017 add_system_value(SYSTEM_VALUE_DRAW_ID, int_t, "gl_DrawID"); 1018 } 1019 if (state->ARB_draw_instanced_enable) 1020 add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceIDARB"); 1021 if (state->ARB_draw_instanced_enable || state->is_version(140, 300)) 1022 add_system_value(SYSTEM_VALUE_INSTANCE_ID, int_t, "gl_InstanceID"); 1023 if (state->ARB_shader_draw_parameters_enable) { 1024 add_system_value(SYSTEM_VALUE_BASE_VERTEX, int_t, "gl_BaseVertexARB"); 1025 add_system_value(SYSTEM_VALUE_BASE_INSTANCE, int_t, "gl_BaseInstanceARB"); 1026 add_system_value(SYSTEM_VALUE_DRAW_ID, int_t, "gl_DrawIDARB"); 1027 } 1028 if (state->AMD_vertex_shader_layer_enable || 1029 state->ARB_shader_viewport_layer_array_enable) { 1030 var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer"); 1031 var->data.interpolation = INTERP_MODE_FLAT; 1032 } 1033 if (state->AMD_vertex_shader_viewport_index_enable || 1034 state->ARB_shader_viewport_layer_array_enable) { 1035 var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex"); 1036 var->data.interpolation = INTERP_MODE_FLAT; 1037 } 1038 if (compatibility) { 1039 add_input(VERT_ATTRIB_POS, vec4_t, "gl_Vertex"); 1040 add_input(VERT_ATTRIB_NORMAL, vec3_t, "gl_Normal"); 1041 add_input(VERT_ATTRIB_COLOR0, vec4_t, "gl_Color"); 1042 add_input(VERT_ATTRIB_COLOR1, vec4_t, "gl_SecondaryColor"); 1043 add_input(VERT_ATTRIB_TEX0, vec4_t, "gl_MultiTexCoord0"); 1044 add_input(VERT_ATTRIB_TEX1, vec4_t, "gl_MultiTexCoord1"); 1045 add_input(VERT_ATTRIB_TEX2, vec4_t, "gl_MultiTexCoord2"); 1046 add_input(VERT_ATTRIB_TEX3, vec4_t, "gl_MultiTexCoord3"); 1047 add_input(VERT_ATTRIB_TEX4, vec4_t, "gl_MultiTexCoord4"); 1048 add_input(VERT_ATTRIB_TEX5, vec4_t, "gl_MultiTexCoord5"); 1049 add_input(VERT_ATTRIB_TEX6, vec4_t, "gl_MultiTexCoord6"); 1050 add_input(VERT_ATTRIB_TEX7, vec4_t, "gl_MultiTexCoord7"); 1051 add_input(VERT_ATTRIB_FOG, float_t, "gl_FogCoord"); 1052 } 1053} 1054 1055 1056/** 1057 * Generate variables which only exist in tessellation control shaders. 1058 */ 1059void 1060builtin_variable_generator::generate_tcs_special_vars() 1061{ 1062 add_system_value(SYSTEM_VALUE_PRIMITIVE_ID, int_t, "gl_PrimitiveID"); 1063 add_system_value(SYSTEM_VALUE_INVOCATION_ID, int_t, "gl_InvocationID"); 1064 add_system_value(SYSTEM_VALUE_VERTICES_IN, int_t, "gl_PatchVerticesIn"); 1065 1066 add_output(VARYING_SLOT_TESS_LEVEL_OUTER, array(float_t, 4), 1067 "gl_TessLevelOuter")->data.patch = 1; 1068 add_output(VARYING_SLOT_TESS_LEVEL_INNER, array(float_t, 2), 1069 "gl_TessLevelInner")->data.patch = 1; 1070 /* XXX What to do if multiple are flipped on? */ 1071 int bbox_slot = state->ctx->Const.NoPrimitiveBoundingBoxOutput ? -1 : 1072 VARYING_SLOT_BOUNDING_BOX0; 1073 if (state->EXT_primitive_bounding_box_enable) 1074 add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBoxEXT") 1075 ->data.patch = 1; 1076 if (state->OES_primitive_bounding_box_enable) 1077 add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBoxOES") 1078 ->data.patch = 1; 1079 if (state->is_version(0, 320) || state->ARB_ES3_2_compatibility_enable) 1080 add_output(bbox_slot, array(vec4_t, 2), "gl_BoundingBox") 1081 ->data.patch = 1; 1082} 1083 1084 1085/** 1086 * Generate variables which only exist in tessellation evaluation shaders. 1087 */ 1088void 1089builtin_variable_generator::generate_tes_special_vars() 1090{ 1091 ir_variable *var; 1092 1093 add_system_value(SYSTEM_VALUE_PRIMITIVE_ID, int_t, "gl_PrimitiveID"); 1094 add_system_value(SYSTEM_VALUE_VERTICES_IN, int_t, "gl_PatchVerticesIn"); 1095 add_system_value(SYSTEM_VALUE_TESS_COORD, vec3_t, "gl_TessCoord"); 1096 if (this->state->ctx->Const.GLSLTessLevelsAsInputs) { 1097 add_input(VARYING_SLOT_TESS_LEVEL_OUTER, array(float_t, 4), 1098 "gl_TessLevelOuter")->data.patch = 1; 1099 add_input(VARYING_SLOT_TESS_LEVEL_INNER, array(float_t, 2), 1100 "gl_TessLevelInner")->data.patch = 1; 1101 } else { 1102 add_system_value(SYSTEM_VALUE_TESS_LEVEL_OUTER, array(float_t, 4), 1103 "gl_TessLevelOuter"); 1104 add_system_value(SYSTEM_VALUE_TESS_LEVEL_INNER, array(float_t, 2), 1105 "gl_TessLevelInner"); 1106 } 1107 if (state->ARB_shader_viewport_layer_array_enable) { 1108 var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer"); 1109 var->data.interpolation = INTERP_MODE_FLAT; 1110 var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex"); 1111 var->data.interpolation = INTERP_MODE_FLAT; 1112 } 1113} 1114 1115 1116/** 1117 * Generate variables which only exist in geometry shaders. 1118 */ 1119void 1120builtin_variable_generator::generate_gs_special_vars() 1121{ 1122 ir_variable *var; 1123 1124 var = add_output(VARYING_SLOT_LAYER, int_t, "gl_Layer"); 1125 var->data.interpolation = INTERP_MODE_FLAT; 1126 if (state->is_version(410, 0) || state->ARB_viewport_array_enable || 1127 state->OES_viewport_array_enable) { 1128 var = add_output(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex"); 1129 var->data.interpolation = INTERP_MODE_FLAT; 1130 } 1131 if (state->is_version(400, 320) || state->ARB_gpu_shader5_enable || 1132 state->OES_geometry_shader_enable || state->EXT_geometry_shader_enable) { 1133 add_system_value(SYSTEM_VALUE_INVOCATION_ID, int_t, "gl_InvocationID"); 1134 } 1135 1136 /* Although gl_PrimitiveID appears in tessellation control and tessellation 1137 * evaluation shaders, it has a different function there than it has in 1138 * geometry shaders, so we treat it (and its counterpart gl_PrimitiveIDIn) 1139 * as special geometry shader variables. 1140 * 1141 * Note that although the general convention of suffixing geometry shader 1142 * input varyings with "In" was not adopted into GLSL 1.50, it is used in 1143 * the specific case of gl_PrimitiveIDIn. So we don't need to treat 1144 * gl_PrimitiveIDIn as an {ARB,EXT}_geometry_shader4-only variable. 1145 */ 1146 var = add_input(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveIDIn"); 1147 var->data.interpolation = INTERP_MODE_FLAT; 1148 var = add_output(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveID"); 1149 var->data.interpolation = INTERP_MODE_FLAT; 1150} 1151 1152 1153/** 1154 * Generate variables which only exist in fragment shaders. 1155 */ 1156void 1157builtin_variable_generator::generate_fs_special_vars() 1158{ 1159 ir_variable *var; 1160 1161 if (this->state->ctx->Const.GLSLFragCoordIsSysVal) 1162 add_system_value(SYSTEM_VALUE_FRAG_COORD, vec4_t, "gl_FragCoord"); 1163 else 1164 add_input(VARYING_SLOT_POS, vec4_t, "gl_FragCoord"); 1165 1166 if (this->state->ctx->Const.GLSLFrontFacingIsSysVal) 1167 add_system_value(SYSTEM_VALUE_FRONT_FACE, bool_t, "gl_FrontFacing"); 1168 else 1169 add_input(VARYING_SLOT_FACE, bool_t, "gl_FrontFacing"); 1170 1171 if (state->is_version(120, 100)) 1172 add_input(VARYING_SLOT_PNTC, vec2_t, "gl_PointCoord"); 1173 1174 if (state->has_geometry_shader()) { 1175 var = add_input(VARYING_SLOT_PRIMITIVE_ID, int_t, "gl_PrimitiveID"); 1176 var->data.interpolation = INTERP_MODE_FLAT; 1177 } 1178 1179 /* gl_FragColor and gl_FragData were deprecated starting in desktop GLSL 1180 * 1.30, and were relegated to the compatibility profile in GLSL 4.20. 1181 * They were removed from GLSL ES 3.00. 1182 */ 1183 if (compatibility || !state->is_version(420, 300)) { 1184 add_output(FRAG_RESULT_COLOR, vec4_t, "gl_FragColor"); 1185 add_output(FRAG_RESULT_DATA0, 1186 array(vec4_t, state->Const.MaxDrawBuffers), "gl_FragData"); 1187 } 1188 1189 if (state->has_framebuffer_fetch() && !state->is_version(130, 300)) { 1190 ir_variable *const var = 1191 add_output(FRAG_RESULT_DATA0, 1192 array(vec4_t, state->Const.MaxDrawBuffers), 1193 "gl_LastFragData"); 1194 var->data.precision = GLSL_PRECISION_MEDIUM; 1195 var->data.read_only = 1; 1196 var->data.fb_fetch_output = 1; 1197 var->data.memory_coherent = 1; 1198 } 1199 1200 if (state->es_shader && state->language_version == 100 && state->EXT_blend_func_extended_enable) { 1201 add_index_output(FRAG_RESULT_COLOR, 1, vec4_t, 1202 "gl_SecondaryFragColorEXT"); 1203 add_index_output(FRAG_RESULT_DATA0, 1, 1204 array(vec4_t, state->Const.MaxDualSourceDrawBuffers), 1205 "gl_SecondaryFragDataEXT"); 1206 } 1207 1208 /* gl_FragDepth has always been in desktop GLSL, but did not appear in GLSL 1209 * ES 1.00. 1210 */ 1211 if (state->is_version(110, 300)) 1212 add_output(FRAG_RESULT_DEPTH, float_t, "gl_FragDepth"); 1213 1214 if (state->EXT_frag_depth_enable) 1215 add_output(FRAG_RESULT_DEPTH, float_t, "gl_FragDepthEXT"); 1216 1217 if (state->ARB_shader_stencil_export_enable) { 1218 ir_variable *const var = 1219 add_output(FRAG_RESULT_STENCIL, int_t, "gl_FragStencilRefARB"); 1220 if (state->ARB_shader_stencil_export_warn) 1221 var->enable_extension_warning("GL_ARB_shader_stencil_export"); 1222 } 1223 1224 if (state->AMD_shader_stencil_export_enable) { 1225 ir_variable *const var = 1226 add_output(FRAG_RESULT_STENCIL, int_t, "gl_FragStencilRefAMD"); 1227 if (state->AMD_shader_stencil_export_warn) 1228 var->enable_extension_warning("GL_AMD_shader_stencil_export"); 1229 } 1230 1231 if (state->is_version(400, 320) || 1232 state->ARB_sample_shading_enable || 1233 state->OES_sample_variables_enable) { 1234 add_system_value(SYSTEM_VALUE_SAMPLE_ID, int_t, "gl_SampleID"); 1235 add_system_value(SYSTEM_VALUE_SAMPLE_POS, vec2_t, "gl_SamplePosition"); 1236 /* From the ARB_sample_shading specification: 1237 * "The number of elements in the array is ceil(<s>/32), where 1238 * <s> is the maximum number of color samples supported by the 1239 * implementation." 1240 * Since no drivers expose more than 32x MSAA, we can simply set 1241 * the array size to 1 rather than computing it. 1242 */ 1243 add_output(FRAG_RESULT_SAMPLE_MASK, array(int_t, 1), "gl_SampleMask"); 1244 } 1245 1246 if (state->is_version(400, 320) || 1247 state->ARB_gpu_shader5_enable || 1248 state->OES_sample_variables_enable) { 1249 add_system_value(SYSTEM_VALUE_SAMPLE_MASK_IN, array(int_t, 1), "gl_SampleMaskIn"); 1250 } 1251 1252 if (state->is_version(430, 320) || 1253 state->ARB_fragment_layer_viewport_enable || 1254 state->OES_geometry_shader_enable || 1255 state->EXT_geometry_shader_enable) { 1256 var = add_input(VARYING_SLOT_LAYER, int_t, "gl_Layer"); 1257 var->data.interpolation = INTERP_MODE_FLAT; 1258 } 1259 1260 if (state->is_version(430, 0) || 1261 state->ARB_fragment_layer_viewport_enable || 1262 state->OES_viewport_array_enable) { 1263 var = add_input(VARYING_SLOT_VIEWPORT, int_t, "gl_ViewportIndex"); 1264 var->data.interpolation = INTERP_MODE_FLAT; 1265 } 1266 1267 if (state->is_version(450, 310) || state->ARB_ES3_1_compatibility_enable) 1268 add_system_value(SYSTEM_VALUE_HELPER_INVOCATION, bool_t, "gl_HelperInvocation"); 1269} 1270 1271 1272/** 1273 * Generate variables which only exist in compute shaders. 1274 */ 1275void 1276builtin_variable_generator::generate_cs_special_vars() 1277{ 1278 add_system_value(SYSTEM_VALUE_LOCAL_INVOCATION_ID, uvec3_t, 1279 "gl_LocalInvocationID"); 1280 add_system_value(SYSTEM_VALUE_WORK_GROUP_ID, uvec3_t, "gl_WorkGroupID"); 1281 add_system_value(SYSTEM_VALUE_NUM_WORK_GROUPS, uvec3_t, "gl_NumWorkGroups"); 1282 1283 if (state->ARB_compute_variable_group_size_enable) { 1284 add_system_value(SYSTEM_VALUE_LOCAL_GROUP_SIZE, 1285 uvec3_t, "gl_LocalGroupSizeARB"); 1286 } 1287 1288 add_system_value(SYSTEM_VALUE_GLOBAL_INVOCATION_ID, 1289 uvec3_t, "gl_GlobalInvocationID"); 1290 add_system_value(SYSTEM_VALUE_LOCAL_INVOCATION_INDEX, 1291 uint_t, "gl_LocalInvocationIndex"); 1292} 1293 1294 1295/** 1296 * Add a single "varying" variable. The variable's type and direction (input 1297 * or output) are adjusted as appropriate for the type of shader being 1298 * compiled. 1299 */ 1300void 1301builtin_variable_generator::add_varying(int slot, const glsl_type *type, 1302 const char *name) 1303{ 1304 switch (state->stage) { 1305 case MESA_SHADER_TESS_CTRL: 1306 case MESA_SHADER_TESS_EVAL: 1307 case MESA_SHADER_GEOMETRY: 1308 this->per_vertex_in.add_field(slot, type, name); 1309 /* FALLTHROUGH */ 1310 case MESA_SHADER_VERTEX: 1311 this->per_vertex_out.add_field(slot, type, name); 1312 break; 1313 case MESA_SHADER_FRAGMENT: 1314 add_input(slot, type, name); 1315 break; 1316 case MESA_SHADER_COMPUTE: 1317 /* Compute shaders don't have varyings. */ 1318 break; 1319 default: 1320 break; 1321 } 1322} 1323 1324 1325/** 1326 * Generate variables that are used to communicate data from one shader stage 1327 * to the next ("varyings"). 1328 */ 1329void 1330builtin_variable_generator::generate_varyings() 1331{ 1332 /* gl_Position and gl_PointSize are not visible from fragment shaders. */ 1333 if (state->stage != MESA_SHADER_FRAGMENT) { 1334 add_varying(VARYING_SLOT_POS, vec4_t, "gl_Position"); 1335 if (!state->es_shader || 1336 state->stage == MESA_SHADER_VERTEX || 1337 (state->stage == MESA_SHADER_GEOMETRY && 1338 (state->OES_geometry_point_size_enable || 1339 state->EXT_geometry_point_size_enable)) || 1340 ((state->stage == MESA_SHADER_TESS_CTRL || 1341 state->stage == MESA_SHADER_TESS_EVAL) && 1342 (state->OES_tessellation_point_size_enable || 1343 state->EXT_tessellation_point_size_enable))) { 1344 add_varying(VARYING_SLOT_PSIZ, float_t, "gl_PointSize"); 1345 } 1346 } 1347 1348 if (state->has_clip_distance()) { 1349 add_varying(VARYING_SLOT_CLIP_DIST0, array(float_t, 0), 1350 "gl_ClipDistance"); 1351 } 1352 if (state->has_cull_distance()) { 1353 add_varying(VARYING_SLOT_CULL_DIST0, array(float_t, 0), 1354 "gl_CullDistance"); 1355 } 1356 1357 if (compatibility) { 1358 add_varying(VARYING_SLOT_TEX0, array(vec4_t, 0), "gl_TexCoord"); 1359 add_varying(VARYING_SLOT_FOGC, float_t, "gl_FogFragCoord"); 1360 if (state->stage == MESA_SHADER_FRAGMENT) { 1361 add_varying(VARYING_SLOT_COL0, vec4_t, "gl_Color"); 1362 add_varying(VARYING_SLOT_COL1, vec4_t, "gl_SecondaryColor"); 1363 } else { 1364 add_varying(VARYING_SLOT_CLIP_VERTEX, vec4_t, "gl_ClipVertex"); 1365 add_varying(VARYING_SLOT_COL0, vec4_t, "gl_FrontColor"); 1366 add_varying(VARYING_SLOT_BFC0, vec4_t, "gl_BackColor"); 1367 add_varying(VARYING_SLOT_COL1, vec4_t, "gl_FrontSecondaryColor"); 1368 add_varying(VARYING_SLOT_BFC1, vec4_t, "gl_BackSecondaryColor"); 1369 } 1370 } 1371 1372 /* Section 7.1 (Built-In Language Variables) of the GLSL 4.00 spec 1373 * says: 1374 * 1375 * "In the tessellation control language, built-in variables are 1376 * intrinsically declared as: 1377 * 1378 * in gl_PerVertex { 1379 * vec4 gl_Position; 1380 * float gl_PointSize; 1381 * float gl_ClipDistance[]; 1382 * } gl_in[gl_MaxPatchVertices];" 1383 */ 1384 if (state->stage == MESA_SHADER_TESS_CTRL || 1385 state->stage == MESA_SHADER_TESS_EVAL) { 1386 const glsl_type *per_vertex_in_type = 1387 this->per_vertex_in.construct_interface_instance(); 1388 add_variable("gl_in", array(per_vertex_in_type, state->Const.MaxPatchVertices), 1389 ir_var_shader_in, -1); 1390 } 1391 if (state->stage == MESA_SHADER_GEOMETRY) { 1392 const glsl_type *per_vertex_in_type = 1393 this->per_vertex_in.construct_interface_instance(); 1394 add_variable("gl_in", array(per_vertex_in_type, 0), 1395 ir_var_shader_in, -1); 1396 } 1397 if (state->stage == MESA_SHADER_TESS_CTRL) { 1398 const glsl_type *per_vertex_out_type = 1399 this->per_vertex_out.construct_interface_instance(); 1400 add_variable("gl_out", array(per_vertex_out_type, 0), 1401 ir_var_shader_out, -1); 1402 } 1403 if (state->stage == MESA_SHADER_VERTEX || 1404 state->stage == MESA_SHADER_TESS_EVAL || 1405 state->stage == MESA_SHADER_GEOMETRY) { 1406 const glsl_type *per_vertex_out_type = 1407 this->per_vertex_out.construct_interface_instance(); 1408 const glsl_struct_field *fields = per_vertex_out_type->fields.structure; 1409 for (unsigned i = 0; i < per_vertex_out_type->length; i++) { 1410 ir_variable *var = 1411 add_variable(fields[i].name, fields[i].type, ir_var_shader_out, 1412 fields[i].location); 1413 var->data.interpolation = fields[i].interpolation; 1414 var->data.centroid = fields[i].centroid; 1415 var->data.sample = fields[i].sample; 1416 var->data.patch = fields[i].patch; 1417 var->data.precision = fields[i].precision; 1418 var->init_interface_type(per_vertex_out_type); 1419 } 1420 } 1421} 1422 1423 1424}; /* Anonymous namespace */ 1425 1426 1427void 1428_mesa_glsl_initialize_variables(exec_list *instructions, 1429 struct _mesa_glsl_parse_state *state) 1430{ 1431 builtin_variable_generator gen(instructions, state); 1432 1433 gen.generate_constants(); 1434 gen.generate_uniforms(); 1435 gen.generate_special_vars(); 1436 1437 gen.generate_varyings(); 1438 1439 switch (state->stage) { 1440 case MESA_SHADER_VERTEX: 1441 gen.generate_vs_special_vars(); 1442 break; 1443 case MESA_SHADER_TESS_CTRL: 1444 gen.generate_tcs_special_vars(); 1445 break; 1446 case MESA_SHADER_TESS_EVAL: 1447 gen.generate_tes_special_vars(); 1448 break; 1449 case MESA_SHADER_GEOMETRY: 1450 gen.generate_gs_special_vars(); 1451 break; 1452 case MESA_SHADER_FRAGMENT: 1453 gen.generate_fs_special_vars(); 1454 break; 1455 case MESA_SHADER_COMPUTE: 1456 gen.generate_cs_special_vars(); 1457 break; 1458 default: 1459 break; 1460 } 1461} 1462