1 #include <msp/core/algorithm.h>
2 #include <msp/core/hash.h>
3 #include <msp/core/raii.h>
4 #include <msp/strings/lexicalcast.h>
6 #include "glsl_error.h"
15 void StructOrganizer::visit(StructDeclaration &strct)
17 SetForScope<int> set_offset(offset, 0);
18 TraversingVisitor::visit(strct);
21 void StructOrganizer::visit(VariableDeclaration &var)
25 int *layout_offset = 0;
26 bool has_matrix_order = false;
29 for(Layout::Qualifier &q: var.layout->qualifiers)
31 if(q.name=="offset" && q.has_value)
33 layout_offset = &q.value;
37 else if(q.name=="column_major" || q.name=="row_major")
38 has_matrix_order = true;
42 MemoryRequirementsCalculator::Result mem_reqs = MemoryRequirementsCalculator().apply(var);
43 offset += mem_reqs.alignment-1;
44 offset -= offset%mem_reqs.alignment;
47 *layout_offset = offset;
49 add_layout_qualifier(var.layout, Layout::Qualifier("offset", offset));
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"));
60 offset += mem_reqs.size;
65 void LocationAllocator::apply(Module &module, const Features &features, bool a)
68 for(Stage &s: module.stages)
71 if(features.target_api!=VULKAN)
72 allocate_locations("uniform");
74 for(InterfaceBlock *b: unbound_blocks)
75 bind_uniform(b->layout, b->block_name, features.uniform_binding_range);
76 for(VariableDeclaration *t: unbound_textures)
77 bind_uniform(t->layout, t->name, features.texture_binding_range);
80 void LocationAllocator::apply(Stage &stage)
82 swap(used_locations["in"], used_locations["out"]);
83 used_locations["out"].clear();
85 stage.content.visit(*this);
87 allocate_locations("in");
88 allocate_locations("out");
91 void LocationAllocator::allocate_locations(const string &iface)
93 auto write = unplaced_variables.begin();
95 for(auto i=unplaced_variables.begin(); i!=unplaced_variables.end(); ++i)
97 if((*i)->interface!=iface)
105 if((*i)->interface=="uniform")
107 auto j = uniforms.find((*i)->name);
108 if(j!=uniforms.end() && j->second.location>=0)
110 add_layout_qualifier((*i)->layout, Layout::Qualifier("location", j->second.location));
118 set<unsigned> &used = used_locations[(*i)->interface];
120 unsigned size = LocationCounter().apply(**i);
124 for(unsigned j=0; j<size; ++j)
125 if(used.count(next+j))
132 add_layout_qualifier((*i)->layout, Layout::Qualifier("location", next));
133 if((*i)->interface=="uniform")
134 uniforms[(*i)->name].location = next;
136 for(unsigned j=0; j<size; ++j)
141 unplaced_variables.erase(write, unplaced_variables.end());
144 void LocationAllocator::bind_uniform(RefPtr<Layout> &layout, const string &name, unsigned range)
146 auto i = uniforms.find(name);
147 if(i!=uniforms.end() && i->second.bind_point>=0)
148 add_layout_qualifier(layout, Layout::Qualifier("binding", i->second.bind_point));
151 set<unsigned> &used = used_bindings[0];
153 unsigned bind_point = fold32(hash64(name))%range;
154 while(used.count(bind_point))
155 bind_point = (bind_point+1)%range;
157 add_layout_qualifier(layout, Layout::Qualifier("binding", bind_point));
158 uniforms[name].bind_point = bind_point;
159 used.insert(bind_point);
163 bool LocationAllocator::visit_uniform(const string &name, RefPtr<Layout> &layout)
165 int bind_point = get_layout_value(layout.get(), "binding");
168 used_bindings[0].insert(bind_point);
169 uniforms[name].bind_point = bind_point;
171 return bind_point>=0;
174 void LocationAllocator::visit(VariableDeclaration &var)
176 if(!var.name.compare(0, 3, "gl_"))
179 if(!var.interface.empty())
181 int location = get_layout_value(var.layout.get(), "location");
183 if(location<0 && var.linked_declaration && var.linked_declaration->layout)
185 location = get_layout_value(var.linked_declaration->layout.get(), "location");
187 add_layout_qualifier(var.layout, Layout::Qualifier("location", location));
192 unsigned size = LocationCounter().apply(var);
193 for(unsigned i=0; i<size; ++i)
194 used_locations[var.interface].insert(location+i);
195 if(var.interface=="uniform")
196 uniforms[var.name].location = location;
199 unplaced_variables.push_back(&var);
202 if(var.interface=="uniform")
204 const TypeDeclaration *base_type = get_ultimate_base_type(var.type_declaration);
205 if(dynamic_cast<const ImageTypeDeclaration *>(base_type) && !visit_uniform(var.name, var.layout))
206 unbound_textures.push_back(&var);
210 void LocationAllocator::visit(InterfaceBlock &iface)
212 if(!iface.instance_name.compare(0, 3, "gl_"))
215 if(iface.interface=="uniform")
217 bool push_constant = has_layout_qualifier(iface.layout.get(), "push_constant");
218 if(!push_constant && !visit_uniform(iface.block_name, iface.layout))
219 unbound_blocks.push_back(&iface);
224 void PrecisionConverter::apply(Stage &s)
227 s.content.visit(*this);
228 NodeRemover().apply(s, nodes_to_remove);
231 void PrecisionConverter::visit(Block &block)
233 for(auto i=block.body.begin(); i!=block.body.end(); ++i)
235 if(&block==&stage->content)
241 void PrecisionConverter::visit(Precision &prec)
243 if(stage->required_features.target_api==OPENGL_ES)
244 have_default.insert(prec.type);
246 nodes_to_remove.insert(&prec);
249 void PrecisionConverter::visit(VariableDeclaration &var)
251 if(stage->required_features.target_api!=OPENGL_ES)
253 var.precision.clear();
257 const char *default_prec = (stage->type==Stage::FRAGMENT ? "mediump" : "highp");
258 const TypeDeclaration *type = var.type_declaration;
261 if(dynamic_cast<const ImageTypeDeclaration *>(type))
263 default_prec = "lowp";
266 else if(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
268 if(basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT)
270 type = basic->base_type;
278 if(!have_default.count(type->name))
280 Precision *prec = new Precision;
281 prec->precision = default_prec;
282 prec->type = type->name;
283 stage->content.body.insert(insert_point, prec);
285 have_default.insert(type->name);
290 void FeatureConverter::apply(Stage &s, const Features &feat)
295 if(!stage->required_features.glsl_version)
296 stage->required_features.glsl_version = Version(1, (stage->required_features.target_api==OPENGL_ES ? 0 : 10));
301 void FeatureConverter::unsupported(const string &reason)
303 Diagnostic diagnostic;
304 diagnostic.severity = Diagnostic::ERR;
305 diagnostic.source = GENERATED_SOURCE;
307 diagnostic.message = reason;
308 stage->diagnostics.push_back(diagnostic);
311 bool FeatureConverter::check_version(const Version &feature_version) const
313 if(features.glsl_version<feature_version)
315 else if(stage->required_features.glsl_version<feature_version)
316 stage->required_features.glsl_version = feature_version;
321 bool FeatureConverter::check_extension(bool Features::*extension) const
323 if(!(features.*extension))
326 stage->required_features.*extension = true;
332 void StructuralFeatureConverter::apply()
334 if(supports_stage(stage->type))
336 stage->content.visit(*this);
337 NodeRemover().apply(*stage, nodes_to_remove);
340 unsupported(format("Stage %s is not supported", Stage::get_stage_name(stage->type)));
343 void StructuralFeatureConverter::visit(Block &block)
345 for(auto i=block.body.begin(); i!=block.body.end(); ++i)
347 if(&block==&stage->content)
348 uniform_insert_point = i;
353 void StructuralFeatureConverter::visit(RefPtr<Expression> &expr)
355 r_replaced_reference = 0;
357 if(r_replaced_reference)
358 expr = r_replaced_reference;
359 r_replaced_reference = 0;
362 bool StructuralFeatureConverter::supports_stage(Stage::Type st) const
364 if(st==Stage::GEOMETRY)
366 if(features.target_api==VULKAN)
368 else if(features.target_api==OPENGL_ES)
369 return check_version(Version(3, 20));
371 return check_version(Version(1, 50));
377 bool StructuralFeatureConverter::supports_unified_interface_syntax() const
379 if(features.target_api==VULKAN)
381 else if(features.target_api==OPENGL_ES)
382 return check_version(Version(3, 0));
384 return check_version(Version(1, 30));
387 void StructuralFeatureConverter::visit(VariableReference &var)
389 if(var.declaration==frag_out && !supports_unified_interface_syntax())
391 var.name = "gl_FragColor";
396 void StructuralFeatureConverter::visit(InterfaceBlockReference &iface)
398 r_flattened_interface = nodes_to_remove.count(iface.declaration);
401 void StructuralFeatureConverter::visit(MemberAccess &memacc)
403 r_flattened_interface = false;
405 if(r_flattened_interface)
407 VariableReference *var = new VariableReference;
408 var->name = memacc.member;
409 r_replaced_reference = var;
413 void StructuralFeatureConverter::visit(Assignment &assign)
415 TraversingVisitor::visit(assign);
416 if(assign.target.declaration==frag_out && !supports_unified_interface_syntax())
417 assign.target.declaration = 0;
420 bool StructuralFeatureConverter::supports_unified_sampling_functions() const
422 if(features.target_api==VULKAN)
424 else if(features.target_api==OPENGL_ES)
425 return check_version(Version(3, 0));
427 return check_version(Version(1, 30));
430 void StructuralFeatureConverter::visit(FunctionCall &call)
432 if(call.declaration && call.declaration->source==BUILTIN_SOURCE)
434 if(!call.name.compare(0, 7, "texture") && call.arguments.size()>=1)
436 const ImageTypeDeclaration *arg_image = dynamic_cast<const ImageTypeDeclaration *>(call.arguments.front()->type);
437 if(arg_image && !supports_unified_sampling_functions())
439 string suffix = call.name.substr(7);
440 call.name = (arg_image->shadow ? "shadow" : "texture");
442 switch(arg_image->dimensions)
444 case ImageTypeDeclaration::ONE: call.name += "1D"; break;
445 case ImageTypeDeclaration::TWO: call.name += "2D"; break;
446 case ImageTypeDeclaration::THREE: call.name += "3D"; break;
447 case ImageTypeDeclaration::CUBE: call.name += "Cube"; break;
452 /* Array textures and the unified sampling function name were
453 both introduced in GLSL 1.30. */
454 if(arg_image->dimensions==ImageTypeDeclaration::ONE || arg_image->dimensions==ImageTypeDeclaration::TWO)
455 check_extension(&Features::ext_texture_array);
456 call.name += "Array";
464 TraversingVisitor::visit(call);
467 void StructuralFeatureConverter::visit(VariableDeclaration &var)
469 if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
470 if(stage->type==Stage::FRAGMENT && var.interface=="out")
473 nodes_to_remove.insert(&var);
476 TraversingVisitor::visit(var);
479 bool StructuralFeatureConverter::supports_interface_blocks(const string &iface) const
481 if(features.target_api==VULKAN)
483 else if(features.target_api==OPENGL_ES)
486 return check_version(Version(3, 0));
488 return check_version(Version(3, 20));
490 else if(check_version(Version(1, 50)))
492 else if(iface=="uniform")
493 return check_extension(&Features::arb_uniform_buffer_object);
498 void StructuralFeatureConverter::visit(InterfaceBlock &iface)
500 bool push_constant = has_layout_qualifier(iface.layout.get(), "push_constant");
501 if((!supports_interface_blocks(iface.interface) || (push_constant && features.target_api!=VULKAN)) && iface.type_declaration)
503 if(!iface.instance_name.empty())
504 unsupported("ARB_uniform_buffer_object required for interface block instances");
505 else if(iface.struct_declaration)
507 for(const RefPtr<Statement> &s: iface.struct_declaration->members.body)
508 if(VariableDeclaration *var = dynamic_cast<VariableDeclaration *>(s.get()))
509 var->interface = iface.interface;
510 stage->content.body.splice(uniform_insert_point, iface.struct_declaration->members.body);
511 nodes_to_remove.insert(&iface);
512 nodes_to_remove.insert(iface.struct_declaration);
515 /* If the interface block is an array, it should have an instance
516 name too, so this should never be reached */
517 throw logic_error("Unexpected interface block configuration");
522 void QualifierConverter::apply()
524 stage->content.visit(*this);
527 bool QualifierConverter::supports_interface_layouts() const
529 if(features.target_api==VULKAN)
531 else if(features.target_api==OPENGL_ES)
532 return check_version(Version(3, 0));
533 else if(check_version(Version(3, 30)))
535 else if(check_version(Version(1, 30)))
536 return check_extension(&Features::arb_explicit_attrib_location);
541 bool QualifierConverter::supports_stage_interface_layouts() const
543 if(features.target_api==VULKAN)
545 else if(features.target_api==OPENGL_ES)
546 return check_version(Version(3, 10));
547 else if(check_version(Version(4, 10)))
550 return check_extension(&Features::arb_separate_shader_objects);
553 bool QualifierConverter::supports_centroid_sampling() const
555 if(features.target_api==VULKAN)
557 else if(features.target_api==OPENGL_ES)
558 return check_version(Version(3, 0));
559 else if(check_version(Version(1, 20)))
562 return check_extension(&Features::ext_gpu_shader4);
565 bool QualifierConverter::supports_sample_sampling() const
567 if(features.target_api==VULKAN)
569 else if(features.target_api==OPENGL_ES)
570 return check_version(Version(3, 20));
571 else if(check_version(Version(4, 0)))
574 return check_extension(&Features::arb_gpu_shader5);
577 bool QualifierConverter::supports_uniform_location() const
579 if(features.target_api==VULKAN)
581 else if(features.target_api==OPENGL_ES)
582 return check_version(Version(3, 10));
583 else if(check_version(Version(4, 30)))
586 return check_extension(&Features::arb_explicit_uniform_location);
589 bool QualifierConverter::supports_binding() const
591 if(features.target_api==VULKAN)
593 else if(features.target_api==OPENGL_ES)
594 return check_version(Version(3, 10));
596 return check_version(Version(4, 20));
599 void QualifierConverter::visit(VariableDeclaration &var)
603 for(auto i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); )
605 if(i->name=="location")
607 bool supported = true;
608 bool external = false;
609 if(var.interface=="in")
611 external = (stage->type==Stage::VERTEX);
612 supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
614 else if(var.interface=="out")
616 external = (stage->type==Stage::FRAGMENT);
617 supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
618 if(external && !supported && !check_extension(&Features::ext_gpu_shader4))
622 unsupported("EXT_gpu_shader4 required for multiple fragment shader outputs");
625 else if(var.interface=="uniform")
626 supported = supports_uniform_location();
631 stage->locations[var.name] = i->value;
632 i = var.layout->qualifiers.erase(i);
637 else if(i->name=="binding" && !supports_binding())
639 if(dynamic_cast<const ImageTypeDeclaration *>(get_ultimate_base_type(var.type_declaration)))
640 stage->texture_bindings[var.name] = i->value;
642 i = var.layout->qualifiers.erase(i);
648 if(var.layout->qualifiers.empty())
652 if(var.sampling=="centroid")
654 if(!supports_centroid_sampling())
655 var.sampling = string();
657 else if(var.sampling=="sample")
659 if(!supports_sample_sampling())
660 var.sampling = string();
663 if(var.name=="gl_ClipDistance")
664 if(const Literal *literal_size = dynamic_cast<const Literal *>(var.array_size.get()))
665 stage->n_clip_distances = literal_size->value.value<int>();
667 TraversingVisitor::visit(var);
670 bool QualifierConverter::supports_interface_block_location() const
672 if(features.target_api==VULKAN)
674 else if(features.target_api==OPENGL_ES)
675 return check_version(Version(3, 20));
676 else if(check_version(Version(4, 40)))
679 return check_extension(&Features::arb_enhanced_layouts);
682 void QualifierConverter::visit(InterfaceBlock &iface)
686 for(auto i=iface.layout->qualifiers.begin(); i!=iface.layout->qualifiers.end(); )
688 if(i->name=="location" && !supports_interface_block_location())
689 i = iface.layout->qualifiers.erase(i);
690 else if(i->name=="binding" && !supports_binding())
692 stage->uniform_block_bindings[iface.block_name] = i->value;
693 i = iface.layout->qualifiers.erase(i);
699 if(iface.layout->qualifiers.empty())