source/glsl/finalize.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/core/hash.h>
   3 #include <msp/core/raii.h>
   4 #include <msp/strings/lexicalcast.h>
   5 #include "finalize.h"
   6 #include "glsl_error.h"
   7 #include "reflect.h"
   8
   9 using namespace std;
  10
  11 namespace Msp {
  12 namespace GL {
  13 namespace SL {
  14
  15 void StructOrganizer::visit(StructDeclaration &strct)
  16 {
  17         SetForScope<int> set_offset(offset, 0);
  18         TraversingVisitor::visit(strct);
  19 }
  20
  21 void StructOrganizer::visit(VariableDeclaration &var)
  22 {
  23         if(offset>=0)
  24         {
  25                 int *layout_offset = 0;
  26                 bool has_matrix_order = false;
  27                 if(var.layout)
  28                 {
  29                         for(Layout::Qualifier &q: var.layout->qualifiers)
  30                         {
  31                                 if(q.name=="offset" && q.has_value)
  32                                 {
  33                                         layout_offset = &q.value;
  34                                         if(q.value>=offset)
  35                                                 offset = q.value;
  36                                 }
  37                                 else if(q.name=="column_major" || q.name=="row_major")
  38                                         has_matrix_order = true;
  39                         }
  40                 }
  41
  42                 MemoryRequirementsCalculator::Result mem_reqs = MemoryRequirementsCalculator().apply(var);
  43                 offset += mem_reqs.alignment-1;
  44                 offset -= offset%mem_reqs.alignment;
  45
  46                 if(layout_offset)
  47                         *layout_offset = offset;
  48                 else
  49                         add_layout_qualifier(var.layout, Layout::Qualifier("offset", offset));
  50
  51                 if(!has_matrix_order)
  52                 {
  53                         const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(var.type_declaration);
  54                         while(basic && basic->kind==BasicTypeDeclaration::ARRAY)
  55                                 basic = dynamic_cast<const BasicTypeDeclaration *>(basic->base_type);
  56                         if(basic && basic->kind==BasicTypeDeclaration::MATRIX)
  57                                 add_layout_qualifier(var.layout, Layout::Qualifier("column_major"));
  58                 }
  59
  60                 offset += mem_reqs.size;
  61         }
  62 }
  63
  64
  65 void LocationAllocator::apply(Module &module, const Features &f, bool a)
  66 {
  67         features = f;
  68         alloc_new = a;
  69         for(Stage &s: module.stages)
  70                 apply(s);
  71
  72         if(features.target_api!=VULKAN)
  73                 allocate_locations("uniform");
  74
  75         for(VariableDeclaration *b: unbound_blocks)
  76                 bind_uniform(b->layout, b->block_declaration->block_name, features.uniform_binding_range);
  77         for(VariableDeclaration *t: unbound_textures)
  78         {
  79                 const TypeDeclaration *base_type = get_ultimate_base_type(t->type_declaration);
  80                 unsigned range = (static_cast<const ImageTypeDeclaration *>(base_type)->sampled ?
  81                         features.texture_binding_range : features.storage_texture_binding_range);
  82                 bind_uniform(t->layout, t->name, range);
  83         }
  84 }
  85
  86 void LocationAllocator::apply(Stage &stage)
  87 {
  88         swap(used_locations["in"], used_locations["out"]);
  89         used_locations["out"].clear();
  90
  91         stage.content.visit(*this);
  92
  93         allocate_locations("in");
  94         allocate_locations("out");
  95 }
  96
  97 void LocationAllocator::allocate_locations(const string &iface)
  98 {
  99         auto write = unplaced_variables.begin();
 100         unsigned next = 0;
 101         for(auto i=unplaced_variables.begin(); i!=unplaced_variables.end(); ++i)
 102         {
 103                 if((*i)->interface!=iface)
 104                 {
 105                         if(write!=i)
 106                                 *write = *i;
 107                         ++write;
 108                         continue;
 109                 }
 110
 111                 if((*i)->interface=="uniform")
 112                 {
 113                         auto j = uniforms.find((*i)->name);
 114                         if(j!=uniforms.end() && j->second.location>=0)
 115                         {
 116                                 add_layout_qualifier((*i)->layout, Layout::Qualifier("location", j->second.location));
 117                                 continue;
 118                         }
 119                 }
 120
 121                 if(!alloc_new)
 122                         continue;
 123
 124                 set<unsigned> &used = used_locations[(*i)->interface];
 125
 126                 unsigned size = LocationCounter().apply(**i);
 127                 while(1)
 128                 {
 129                         int blocking = -1;
 130                         for(unsigned j=0; j<size; ++j)
 131                                 if(used.count(next+j))
 132                                         blocking = next+j;
 133                         if(blocking<0)
 134                                 break;
 135                         next = blocking+1;
 136                 }
 137
 138                 add_layout_qualifier((*i)->layout, Layout::Qualifier("location", next));
 139                 if((*i)->interface=="uniform")
 140                         uniforms[(*i)->name].location = next;
 141
 142                 for(unsigned j=0; j<size; ++j)
 143                         used.insert(next+j);
 144                 next += size;
 145         }
 146
 147         unplaced_variables.erase(write, unplaced_variables.end());
 148 }
 149
 150 void LocationAllocator::bind_uniform(RefPtr<Layout> &layout, const string &name, unsigned range)
 151 {
 152         auto i = uniforms.find(name);
 153
 154         int desc_set = (i!=uniforms.end() ? i->second.desc_set : 0);
 155         if(features.target_api==VULKAN && get_layout_value(layout.get(), "set")<0)
 156                 add_layout_qualifier(layout, Layout::Qualifier("set", desc_set));
 157
 158         if(i!=uniforms.end() && i->second.bind_point>=0)
 159                 add_layout_qualifier(layout, Layout::Qualifier("binding", i->second.bind_point));
 160         else if(alloc_new)
 161         {
 162                 set<unsigned> &used = used_bindings[desc_set];
 163
 164                 unsigned bind_point = hash_fold<32>(hash<64>(name))%range;
 165                 while(used.count(bind_point))
 166                         bind_point = (bind_point+1)%range;
 167
 168                 add_layout_qualifier(layout, Layout::Qualifier("binding", bind_point));
 169                 uniforms[name].bind_point = bind_point;
 170                 used.insert(bind_point);
 171         }
 172 }
 173
 174 bool LocationAllocator::visit_uniform(const string &name, RefPtr<Layout> &layout)
 175 {
 176         int desc_set = get_layout_value(layout.get(), "set");
 177         int bind_point = get_layout_value(layout.get(), "binding");
 178
 179         if(features.target_api==VULKAN)
 180         {
 181                 if(desc_set<0 && bind_point>=0)
 182                 {
 183                         desc_set = 0;
 184                         add_layout_qualifier(layout, Layout::Qualifier("set", desc_set));
 185                 }
 186
 187                 if(desc_set>=0)
 188                         uniforms[name].desc_set = desc_set;
 189         }
 190         else if(desc_set>=0 && bind_point<0)
 191         {
 192                 auto i = find_member(layout->qualifiers, string("set"), &Layout::Qualifier::name);
 193                 layout->qualifiers.erase(i);
 194         }
 195
 196         if(bind_point>=0)
 197         {
 198                 used_bindings[desc_set].insert(bind_point);
 199                 uniforms[name].bind_point = bind_point;
 200         }
 201
 202         return bind_point>=0;
 203 }
 204
 205 void LocationAllocator::visit(VariableDeclaration &var)
 206 {
 207         if(!var.name.compare(0, 3, "gl_"))
 208                 return;
 209
 210         if(!var.interface.empty() && !var.block_declaration)
 211         {
 212                 int location = get_layout_value(var.layout.get(), "location");
 213
 214                 if(location<0 && var.linked_declaration && var.linked_declaration->layout)
 215                 {
 216                         location = get_layout_value(var.linked_declaration->layout.get(), "location");
 217                         if(location>=0)
 218                                 add_layout_qualifier(var.layout, Layout::Qualifier("location", location));
 219                 }
 220
 221                 if(location>=0)
 222                 {
 223                         unsigned size = LocationCounter().apply(var);
 224                         for(unsigned i=0; i<size; ++i)
 225                                 used_locations[var.interface].insert(location+i);
 226                         if(var.interface=="uniform")
 227                                 uniforms[var.name].location = location;
 228                 }
 229                 else
 230                         unplaced_variables.push_back(&var);
 231         }
 232
 233         if(var.interface=="uniform")
 234         {
 235                 if(var.block_declaration)
 236                 {
 237                         bool push_constant = has_layout_qualifier(var.layout.get(), "push_constant");
 238                         if(!push_constant && !visit_uniform(var.block_declaration->block_name, var.layout))
 239                                 unbound_blocks.push_back(&var);
 240                 }
 241                 else
 242                 {
 243                         const TypeDeclaration *base_type = get_ultimate_base_type(var.type_declaration);
 244                         if(dynamic_cast<const ImageTypeDeclaration *>(base_type) && !visit_uniform(var.name, var.layout))
 245                                 unbound_textures.push_back(&var);
 246                 }
 247         }
 248 }
 249
 250
 251 void DepthRangeConverter::apply(Stage &stage, const Features &features)
 252 {
 253         if(stage.type!=Stage::VERTEX || features.target_api==VULKAN)
 254                 return;
 255
 256         stage.content.visit(*this);
 257 }
 258
 259 void DepthRangeConverter::visit(VariableReference &var)
 260 {
 261         const StructDeclaration *strct = dynamic_cast<const StructDeclaration *>(var.type);
 262         r_gl_pervertex = (strct && strct->block_name=="gl_PerVertex");
 263 }
 264
 265 void DepthRangeConverter::visit(MemberAccess &memacc)
 266 {
 267         r_gl_pervertex = false;
 268         memacc.left->visit(*this);
 269         r_gl_position = (r_gl_pervertex && memacc.member=="gl_Position");
 270 }
 271
 272 void DepthRangeConverter::visit(Swizzle &swiz)
 273 {
 274         r_gl_position = false;
 275         swiz.left->visit(*this);
 276         if(assignment_target && r_gl_position && swiz.count==1 && swiz.components[0]==2)
 277                 r_position_z_assigned = true;
 278 }
 279
 280 void DepthRangeConverter::visit(Assignment &assign)
 281 {
 282         {
 283                 SetFlag set_target(assignment_target);
 284                 assign.left->visit(*this);
 285         }
 286         assign.right->visit(*this);
 287 }
 288
 289 void DepthRangeConverter::visit(FunctionDeclaration &func)
 290 {
 291         r_position_z_assigned = false;
 292         TraversingVisitor::visit(func);
 293
 294         if(func.definition==&func && func.name=="main" && !r_position_z_assigned)
 295         {
 296                 VariableReference *position = new VariableReference;
 297                 position->name = "gl_Position";
 298
 299                 MemberAccess *z = new MemberAccess;
 300                 z->left = position;
 301                 z->member = "z";
 302
 303                 Literal *scale = new Literal;
 304                 scale->token = "2.0";
 305                 scale->value = 2.0f;
 306
 307                 BinaryExpression *multiply = new BinaryExpression;
 308                 multiply->oper = &Operator::get_operator("*", Operator::BINARY);
 309                 multiply->left = z;
 310                 multiply->right = scale;
 311
 312                 MemberAccess *w = new MemberAccess;
 313                 w->left = position->clone();
 314                 w->member = "w";
 315
 316                 BinaryExpression *subtract = new BinaryExpression;
 317                 subtract->oper = &Operator::get_operator("-", Operator::BINARY);
 318                 subtract->left = multiply;
 319                 subtract->right = w;
 320
 321                 Assignment *assign = new Assignment;
 322                 assign->oper = &Operator::get_operator("=", Operator::BINARY);
 323                 assign->left = z->clone();
 324                 assign->right = subtract;
 325
 326                 ExpressionStatement *statement = new ExpressionStatement;
 327                 statement->expression = assign;
 328
 329                 func.body.body.push_back(statement);
 330         }
 331 }
 332
 333
 334 void PrecisionConverter::apply(Stage &s)
 335 {
 336         stage = &s;
 337         s.content.visit(*this);
 338         NodeRemover().apply(s, nodes_to_remove);
 339 }
 340
 341 void PrecisionConverter::visit(Block &block)
 342 {
 343         for(auto i=block.body.begin(); i!=block.body.end(); ++i)
 344         {
 345                 if(&block==&stage->content)
 346                         insert_point = i;
 347                 (*i)->visit(*this);
 348         }
 349 }
 350
 351 void PrecisionConverter::visit(Precision &prec)
 352 {
 353         if(stage->required_features.target_api==OPENGL_ES)
 354                 have_default.insert(prec.type);
 355         else
 356                 nodes_to_remove.insert(&prec);
 357 }
 358
 359 void PrecisionConverter::visit(VariableDeclaration &var)
 360 {
 361         if(stage->required_features.target_api!=OPENGL_ES)
 362         {
 363                 var.precision.clear();
 364                 return;
 365         }
 366
 367         const char *default_prec = (stage->type==Stage::FRAGMENT ? "mediump" : "highp");
 368         const TypeDeclaration *type = var.type_declaration;
 369         while(type)
 370         {
 371                 if(dynamic_cast<const ImageTypeDeclaration *>(type))
 372                 {
 373                         default_prec = "lowp";
 374                         break;
 375                 }
 376                 else if(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
 377                 {
 378                         if(basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT)
 379                                 break;
 380                         type = basic->base_type;
 381                 }
 382                 else
 383                         return;
 384         }
 385         if(!type)
 386                 return;
 387
 388         if(!have_default.count(type->name))
 389         {
 390                 Precision *prec = new Precision;
 391                 prec->precision = default_prec;
 392                 prec->type = type->name;
 393                 stage->content.body.insert(insert_point, prec);
 394
 395                 have_default.insert(type->name);
 396         }
 397 }
 398
 399
 400 void FeatureConverter::apply(Stage &s, const Features &feat)
 401 {
 402         stage = &s;
 403         features = feat;
 404
 405         if(!stage->required_features.glsl_version)
 406                 stage->required_features.glsl_version = Version(1, (stage->required_features.target_api==OPENGL_ES ? 0 : 10));
 407
 408         apply();
 409 }
 410
 411 void FeatureConverter::unsupported(const string &reason)
 412 {
 413         Diagnostic diagnostic;
 414         diagnostic.severity = Diagnostic::ERR;
 415         diagnostic.source = GENERATED_SOURCE;
 416         diagnostic.line = 0;
 417         diagnostic.message = reason;
 418         stage->diagnostics.push_back(diagnostic);
 419 }
 420
 421 bool FeatureConverter::check_version(const Version &feature_version) const
 422 {
 423         if(features.glsl_version<feature_version)
 424                 return false;
 425         else if(stage->required_features.glsl_version<feature_version)
 426                 stage->required_features.glsl_version = feature_version;
 427
 428         return true;
 429 }
 430
 431 bool FeatureConverter::check_extension(bool Features::*extension) const
 432 {
 433         if(!(features.*extension))
 434                 return false;
 435
 436         stage->required_features.*extension = true;
 437
 438         return true;
 439 }
 440
 441
 442 void StructuralFeatureConverter::apply()
 443 {
 444         if(supports_stage(stage->type))
 445         {
 446                 stage->content.visit(*this);
 447                 NodeRemover().apply(*stage, nodes_to_remove);
 448         }
 449         else
 450                 unsupported(format("Stage %s is not supported", Stage::get_stage_name(stage->type)));
 451 }
 452
 453 void StructuralFeatureConverter::visit(Block &block)
 454 {
 455         for(auto i=block.body.begin(); i!=block.body.end(); ++i)
 456         {
 457                 if(&block==&stage->content)
 458                         uniform_insert_point = i;
 459                 (*i)->visit(*this);
 460         }
 461 }
 462
 463 void StructuralFeatureConverter::visit(RefPtr<Expression> &expr)
 464 {
 465         r_replaced_reference = 0;
 466         expr->visit(*this);
 467         if(r_replaced_reference)
 468                 expr = r_replaced_reference;
 469         r_replaced_reference = 0;
 470 }
 471
 472 bool StructuralFeatureConverter::supports_stage(Stage::Type st) const
 473 {
 474         if(st==Stage::TESS_CONTROL || st==Stage::TESS_EVAL)
 475         {
 476                 if(features.target_api==OPENGL_ES)
 477                         return check_version(Version(3, 20));
 478                 else
 479                         return check_version(Version(4, 0));
 480         }
 481         else if(st==Stage::GEOMETRY)
 482         {
 483                 if(features.target_api==OPENGL_ES)
 484                         return check_version(Version(3, 20));
 485                 else
 486                         return check_version(Version(1, 50));
 487         }
 488         else if(st==Stage::COMPUTE)
 489         {
 490                 if(features.target_api==OPENGL_ES)
 491                         return check_version(Version(3, 10));
 492                 else
 493                         return check_version(Version(4, 30));
 494         }
 495         else
 496                 return true;
 497 }
 498
 499 bool StructuralFeatureConverter::supports_unified_interface_syntax() const
 500 {
 501         if(features.target_api==OPENGL_ES)
 502                 return check_version(Version(3, 0));
 503         else
 504                 return check_version(Version(1, 30));
 505 }
 506
 507 void StructuralFeatureConverter::visit(VariableReference &var)
 508 {
 509         if(var.declaration==frag_out && !supports_unified_interface_syntax())
 510         {
 511                 var.name = "gl_FragColor";
 512                 var.declaration = 0;
 513         }
 514
 515         r_flattened_interface = nodes_to_remove.count(var.declaration);
 516 }
 517
 518 void StructuralFeatureConverter::visit(MemberAccess &memacc)
 519 {
 520         r_flattened_interface = false;
 521         visit(memacc.left);
 522         if(r_flattened_interface)
 523         {
 524                 VariableReference *var = new VariableReference;
 525                 var->name = memacc.member;
 526                 r_replaced_reference = var;
 527         }
 528 }
 529
 530 void StructuralFeatureConverter::visit(Assignment &assign)
 531 {
 532         TraversingVisitor::visit(assign);
 533         if(assign.target.declaration==frag_out && !supports_unified_interface_syntax())
 534                 assign.target.declaration = 0;
 535 }
 536
 537 bool StructuralFeatureConverter::supports_unified_sampling_functions() const
 538 {
 539         if(features.target_api==OPENGL_ES)
 540                 return check_version(Version(3, 0));
 541         else
 542                 return check_version(Version(1, 30));
 543 }
 544
 545 void StructuralFeatureConverter::visit(FunctionCall &call)
 546 {
 547         if(call.declaration && call.declaration->source==BUILTIN_SOURCE)
 548         {
 549                 if(!call.name.compare(0, 7, "texture") && call.arguments.size()>=1)
 550                 {
 551                         const ImageTypeDeclaration *arg_image = dynamic_cast<const ImageTypeDeclaration *>(call.arguments.front()->type);
 552                         if(arg_image && !supports_unified_sampling_functions())
 553                         {
 554                                 string suffix = call.name.substr(7);
 555                                 call.name = (arg_image->shadow ? "shadow" : "texture");
 556
 557                                 switch(arg_image->dimensions)
 558                                 {
 559                                 case ImageTypeDeclaration::ONE: call.name += "1D"; break;
 560                                 case ImageTypeDeclaration::TWO: call.name += "2D"; break;
 561                                 case ImageTypeDeclaration::THREE: call.name += "3D"; break;
 562                                 case ImageTypeDeclaration::CUBE: call.name += "Cube"; break;
 563                                 }
 564
 565                                 if(arg_image->array)
 566                                 {
 567                                         /* Array textures and the unified sampling function name were
 568                                         both introduced in GLSL 1.30. */
 569                                         if(arg_image->dimensions==ImageTypeDeclaration::ONE || arg_image->dimensions==ImageTypeDeclaration::TWO)
 570                                                 check_extension(&Features::ext_texture_array);
 571                                         call.name += "Array";
 572                                 }
 573
 574                                 call.name += suffix;
 575                         }
 576                 }
 577         }
 578
 579         TraversingVisitor::visit(call);
 580 }
 581
 582 bool StructuralFeatureConverter::supports_interface_blocks(const string &iface) const
 583 {
 584         if(features.target_api==OPENGL_ES)
 585         {
 586                 if(iface=="uniform")
 587                         return check_version(Version(3, 0));
 588                 else
 589                         return check_version(Version(3, 20));
 590         }
 591         else if(check_version(Version(1, 50)))
 592                 return true;
 593         else if(iface=="uniform")
 594                 return check_extension(&Features::arb_uniform_buffer_object);
 595         else
 596                 return false;
 597 }
 598
 599 void StructuralFeatureConverter::visit(VariableDeclaration &var)
 600 {
 601         if(var.block_declaration)
 602         {
 603                 bool push_constant = has_layout_qualifier(var.layout.get(), "push_constant");
 604                 if(!supports_interface_blocks(var.interface) || (push_constant && features.target_api!=VULKAN))
 605                 {
 606                         if(var.name.find(' ')==string::npos)
 607                                 unsupported("ARB_uniform_buffer_object required for interface block instances");
 608                         else
 609                         {
 610                                 for(const RefPtr<Statement> &s: var.block_declaration->members.body)
 611                                         if(VariableDeclaration *mem = dynamic_cast<VariableDeclaration *>(s.get()))
 612                                                 mem->interface = var.interface;
 613                                 stage->content.body.splice(uniform_insert_point, var.block_declaration->members.body);
 614                                 nodes_to_remove.insert(&var);
 615                                 nodes_to_remove.insert(var.block_declaration);
 616                         }
 617                 }
 618         }
 619
 620         if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
 621                 if(stage->type==Stage::FRAGMENT && var.interface=="out")
 622                 {
 623                         frag_out = &var;
 624                         nodes_to_remove.insert(&var);
 625                 }
 626
 627         TraversingVisitor::visit(var);
 628 }
 629
 630
 631 void QualifierConverter::apply()
 632 {
 633         stage->content.visit(*this);
 634 }
 635
 636 bool QualifierConverter::supports_interface_layouts() const
 637 {
 638         if(features.target_api==OPENGL_ES)
 639                 return check_version(Version(3, 0));
 640         else if(check_version(Version(3, 30)))
 641                 return true;
 642         else if(check_version(Version(1, 30)))
 643                 return check_extension(&Features::arb_explicit_attrib_location);
 644         else
 645                 return false;
 646 }
 647
 648 bool QualifierConverter::supports_stage_interface_layouts() const
 649 {
 650         if(features.target_api==OPENGL_ES)
 651                 return check_version(Version(3, 10));
 652         else if(check_version(Version(4, 10)))
 653                 return true;
 654         else
 655                 return check_extension(&Features::arb_separate_shader_objects);
 656 }
 657
 658 bool QualifierConverter::supports_centroid_sampling() const
 659 {
 660         if(features.target_api==OPENGL_ES)
 661                 return check_version(Version(3, 0));
 662         else if(check_version(Version(1, 20)))
 663                 return true;
 664         else
 665                 return check_extension(&Features::ext_gpu_shader4);
 666 }
 667
 668 bool QualifierConverter::supports_sample_sampling() const
 669 {
 670         if(features.target_api==OPENGL_ES)
 671                 return check_version(Version(3, 20));
 672         else if(check_version(Version(4, 0)))
 673                 return true;
 674         else
 675                 return check_extension(&Features::arb_gpu_shader5);
 676 }
 677
 678 bool QualifierConverter::supports_uniform_location() const
 679 {
 680         if(features.target_api==OPENGL_ES)
 681                 return check_version(Version(3, 10));
 682         else if(check_version(Version(4, 30)))
 683                 return true;
 684         else
 685                 return check_extension(&Features::arb_explicit_uniform_location);
 686 }
 687
 688 bool QualifierConverter::supports_binding() const
 689 {
 690         if(features.target_api==OPENGL_ES)
 691                 return check_version(Version(3, 10));
 692         else
 693                 return check_version(Version(4, 20));
 694 }
 695
 696 bool QualifierConverter::supports_interface_block_location() const
 697 {
 698         if(features.target_api==OPENGL_ES)
 699                 return check_version(Version(3, 20));
 700         else if(check_version(Version(4, 40)))
 701                 return true;
 702         else
 703                 return check_extension(&Features::arb_enhanced_layouts);
 704 }
 705
 706 void QualifierConverter::visit(VariableDeclaration &var)
 707 {
 708         if(var.layout)
 709         {
 710                 for(auto i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); )
 711                 {
 712                         if(i->name=="location")
 713                         {
 714                                 bool supported = true;
 715                                 bool external = false;
 716                                 if(var.block_declaration)
 717                                         supported = supports_interface_block_location();
 718                                 else if(var.interface=="in")
 719                                 {
 720                                         external = (stage->type==Stage::VERTEX);
 721                                         supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
 722                                 }
 723                                 else if(var.interface=="out")
 724                                 {
 725                                         external = (stage->type==Stage::FRAGMENT);
 726                                         supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
 727                                         if(external && !supported && !check_extension(&Features::ext_gpu_shader4))
 728                                         {
 729                                                 external = false;
 730                                                 if(i->value!=0)
 731                                                         unsupported("EXT_gpu_shader4 required for multiple fragment shader outputs");
 732                                         }
 733                                 }
 734                                 else if(var.interface=="uniform")
 735                                         supported = supports_uniform_location();
 736
 737                                 if(!supported)
 738                                 {
 739                                         if(external)
 740                                                 stage->locations[var.name] = i->value;
 741                                         i = var.layout->qualifiers.erase(i);
 742                                 }
 743                                 else
 744                                         ++i;
 745                         }
 746                         else if(i->name=="binding" && !supports_binding())
 747                         {
 748                                 if(var.block_declaration)
 749                                         stage->uniform_block_bindings[var.block_declaration->block_name] = i->value;
 750                                 else if(dynamic_cast<const ImageTypeDeclaration *>(get_ultimate_base_type(var.type_declaration)))
 751                                         stage->texture_bindings[var.name] = i->value;
 752
 753                                 i = var.layout->qualifiers.erase(i);
 754                         }
 755                         else
 756                                 ++i;
 757                 }
 758
 759                 if(var.layout->qualifiers.empty())
 760                         var.layout = 0;
 761         }
 762
 763         if(var.sampling=="centroid")
 764         {
 765                 if(!supports_centroid_sampling())
 766                         var.sampling = string();
 767         }
 768         else if(var.sampling=="sample")
 769         {
 770                 if(!supports_sample_sampling())
 771                         var.sampling = string();
 772         }
 773
 774         if(var.name=="gl_ClipDistance")
 775                 if(const Literal *literal_size = dynamic_cast<const Literal *>(var.array_size.get()))
 776                         stage->n_clip_distances = literal_size->value.value<int>();
 777
 778         TraversingVisitor::visit(var);
 779 }
 780
 781 } // namespace SL
 782 } // namespace GL
 783 } // namespace Msp