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