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