]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/finalize.cpp
Fix reflection of image types from Spir-V modules
[libs/gl.git] / 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(InterfaceBlock *b: unbound_blocks)
76                 bind_uniform(b->layout, b->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 = 0;
172         int bind_point = get_layout_value(layout.get(), "binding");
173
174         if(features.target_api==VULKAN)
175         {
176                 desc_set = get_layout_value(layout.get(), "set");
177                 if(desc_set<0 && bind_point>=0)
178                 {
179                         desc_set = 0;
180                         add_layout_qualifier(layout, Layout::Qualifier("set", desc_set));
181                 }
182
183                 if(desc_set>=0)
184                         uniforms[name].desc_set = desc_set;
185         }
186
187         if(bind_point>=0)
188         {
189                 used_bindings[desc_set].insert(bind_point);
190                 uniforms[name].bind_point = bind_point;
191         }
192
193         return bind_point>=0;
194 }
195
196 void LocationAllocator::visit(VariableDeclaration &var)
197 {
198         if(!var.name.compare(0, 3, "gl_"))
199                 return;
200
201         if(!var.interface.empty())
202         {
203                 int location = get_layout_value(var.layout.get(), "location");
204
205                 if(location<0 && var.linked_declaration && var.linked_declaration->layout)
206                 {
207                         location = get_layout_value(var.linked_declaration->layout.get(), "location");
208                         if(location>=0)
209                                 add_layout_qualifier(var.layout, Layout::Qualifier("location", location));
210                 }
211
212                 if(location>=0)
213                 {
214                         unsigned size = LocationCounter().apply(var);
215                         for(unsigned i=0; i<size; ++i)
216                                 used_locations[var.interface].insert(location+i);
217                         if(var.interface=="uniform")
218                                 uniforms[var.name].location = location;
219                 }
220                 else
221                         unplaced_variables.push_back(&var);
222         }
223
224         if(var.interface=="uniform")
225         {
226                 const TypeDeclaration *base_type = get_ultimate_base_type(var.type_declaration);
227                 if(dynamic_cast<const ImageTypeDeclaration *>(base_type) && !visit_uniform(var.name, var.layout))
228                         unbound_textures.push_back(&var);
229         }
230 }
231
232 void LocationAllocator::visit(InterfaceBlock &iface)
233 {
234         if(!iface.instance_name.compare(0, 3, "gl_"))
235                 return;
236
237         if(iface.interface=="uniform")
238         {
239                 bool push_constant = has_layout_qualifier(iface.layout.get(), "push_constant");
240                 if(!push_constant && !visit_uniform(iface.block_name, iface.layout))
241                         unbound_blocks.push_back(&iface);
242         }
243 }
244
245
246 void PrecisionConverter::apply(Stage &s)
247 {
248         stage = &s;
249         s.content.visit(*this);
250         NodeRemover().apply(s, nodes_to_remove);
251 }
252
253 void PrecisionConverter::visit(Block &block)
254 {
255         for(auto i=block.body.begin(); i!=block.body.end(); ++i)
256         {
257                 if(&block==&stage->content)
258                         insert_point = i;
259                 (*i)->visit(*this);
260         }
261 }
262
263 void PrecisionConverter::visit(Precision &prec)
264 {
265         if(stage->required_features.target_api==OPENGL_ES)
266                 have_default.insert(prec.type);
267         else
268                 nodes_to_remove.insert(&prec);
269 }
270
271 void PrecisionConverter::visit(VariableDeclaration &var)
272 {
273         if(stage->required_features.target_api!=OPENGL_ES)
274         {
275                 var.precision.clear();
276                 return;
277         }
278
279         const char *default_prec = (stage->type==Stage::FRAGMENT ? "mediump" : "highp");
280         const TypeDeclaration *type = var.type_declaration;
281         while(type)
282         {
283                 if(dynamic_cast<const ImageTypeDeclaration *>(type))
284                 {
285                         default_prec = "lowp";
286                         break;
287                 }
288                 else if(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
289                 {
290                         if(basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT)
291                                 break;
292                         type = basic->base_type;
293                 }
294                 else
295                         return;
296         }
297         if(!type)
298                 return;
299
300         if(!have_default.count(type->name))
301         {
302                 Precision *prec = new Precision;
303                 prec->precision = default_prec;
304                 prec->type = type->name;
305                 stage->content.body.insert(insert_point, prec);
306
307                 have_default.insert(type->name);
308         }
309 }
310
311
312 void FeatureConverter::apply(Stage &s, const Features &feat)
313 {
314         stage = &s;
315         features = feat;
316
317         if(!stage->required_features.glsl_version)
318                 stage->required_features.glsl_version = Version(1, (stage->required_features.target_api==OPENGL_ES ? 0 : 10));
319
320         apply();
321 }
322
323 void FeatureConverter::unsupported(const string &reason)
324 {
325         Diagnostic diagnostic;
326         diagnostic.severity = Diagnostic::ERR;
327         diagnostic.source = GENERATED_SOURCE;
328         diagnostic.line = 0;
329         diagnostic.message = reason;
330         stage->diagnostics.push_back(diagnostic);
331 }
332
333 bool FeatureConverter::check_version(const Version &feature_version) const
334 {
335         if(features.glsl_version<feature_version)
336                 return false;
337         else if(stage->required_features.glsl_version<feature_version)
338                 stage->required_features.glsl_version = feature_version;
339
340         return true;
341 }
342
343 bool FeatureConverter::check_extension(bool Features::*extension) const
344 {
345         if(!(features.*extension))
346                 return false;
347
348         stage->required_features.*extension = true;
349
350         return true;
351 }
352
353
354 void StructuralFeatureConverter::apply()
355 {
356         if(supports_stage(stage->type))
357         {
358                 stage->content.visit(*this);
359                 NodeRemover().apply(*stage, nodes_to_remove);
360         }
361         else
362                 unsupported(format("Stage %s is not supported", Stage::get_stage_name(stage->type)));
363 }
364
365 void StructuralFeatureConverter::visit(Block &block)
366 {
367         for(auto i=block.body.begin(); i!=block.body.end(); ++i)
368         {
369                 if(&block==&stage->content)
370                         uniform_insert_point = i;
371                 (*i)->visit(*this);
372         }
373 }
374
375 void StructuralFeatureConverter::visit(RefPtr<Expression> &expr)
376 {
377         r_replaced_reference = 0;
378         expr->visit(*this);
379         if(r_replaced_reference)
380                 expr = r_replaced_reference;
381         r_replaced_reference = 0;
382 }
383
384 bool StructuralFeatureConverter::supports_stage(Stage::Type st) const
385 {
386         if(st==Stage::GEOMETRY)
387         {
388                 if(features.target_api==VULKAN)
389                         return true;
390                 else if(features.target_api==OPENGL_ES)
391                         return check_version(Version(3, 20));
392                 else
393                         return check_version(Version(1, 50));
394         }
395         else
396                 return true;
397 }
398
399 bool StructuralFeatureConverter::supports_unified_interface_syntax() const
400 {
401         if(features.target_api==VULKAN)
402                 return true;
403         else if(features.target_api==OPENGL_ES)
404                 return check_version(Version(3, 0));
405         else
406                 return check_version(Version(1, 30));
407 }
408
409 void StructuralFeatureConverter::visit(VariableReference &var)
410 {
411         if(var.declaration==frag_out && !supports_unified_interface_syntax())
412         {
413                 var.name = "gl_FragColor";
414                 var.declaration = 0;
415         }
416 }
417
418 void StructuralFeatureConverter::visit(InterfaceBlockReference &iface)
419 {
420         r_flattened_interface = nodes_to_remove.count(iface.declaration);
421 }
422
423 void StructuralFeatureConverter::visit(MemberAccess &memacc)
424 {
425         r_flattened_interface = false;
426         visit(memacc.left);
427         if(r_flattened_interface)
428         {
429                 VariableReference *var = new VariableReference;
430                 var->name = memacc.member;
431                 r_replaced_reference = var;
432         }
433 }
434
435 void StructuralFeatureConverter::visit(Assignment &assign)
436 {
437         TraversingVisitor::visit(assign);
438         if(assign.target.declaration==frag_out && !supports_unified_interface_syntax())
439                 assign.target.declaration = 0;
440 }
441
442 bool StructuralFeatureConverter::supports_unified_sampling_functions() const
443 {
444         if(features.target_api==VULKAN)
445                 return true;
446         else if(features.target_api==OPENGL_ES)
447                 return check_version(Version(3, 0));
448         else
449                 return check_version(Version(1, 30));
450 }
451
452 void StructuralFeatureConverter::visit(FunctionCall &call)
453 {
454         if(call.declaration && call.declaration->source==BUILTIN_SOURCE)
455         {
456                 if(!call.name.compare(0, 7, "texture") && call.arguments.size()>=1)
457                 {
458                         const ImageTypeDeclaration *arg_image = dynamic_cast<const ImageTypeDeclaration *>(call.arguments.front()->type);
459                         if(arg_image && !supports_unified_sampling_functions())
460                         {
461                                 string suffix = call.name.substr(7);
462                                 call.name = (arg_image->shadow ? "shadow" : "texture");
463
464                                 switch(arg_image->dimensions)
465                                 {
466                                 case ImageTypeDeclaration::ONE: call.name += "1D"; break;
467                                 case ImageTypeDeclaration::TWO: call.name += "2D"; break;
468                                 case ImageTypeDeclaration::THREE: call.name += "3D"; break;
469                                 case ImageTypeDeclaration::CUBE: call.name += "Cube"; break;
470                                 }
471
472                                 if(arg_image->array)
473                                 {
474                                         /* Array textures and the unified sampling function name were
475                                         both introduced in GLSL 1.30. */
476                                         if(arg_image->dimensions==ImageTypeDeclaration::ONE || arg_image->dimensions==ImageTypeDeclaration::TWO)
477                                                 check_extension(&Features::ext_texture_array);
478                                         call.name += "Array";
479                                 }
480
481                                 call.name += suffix;
482                         }
483                 }
484         }
485
486         TraversingVisitor::visit(call);
487 }
488
489 void StructuralFeatureConverter::visit(VariableDeclaration &var)
490 {
491         if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
492                 if(stage->type==Stage::FRAGMENT && var.interface=="out")
493                 {
494                         frag_out = &var;
495                         nodes_to_remove.insert(&var);
496                 }
497
498         TraversingVisitor::visit(var);
499 }
500
501 bool StructuralFeatureConverter::supports_interface_blocks(const string &iface) const
502 {
503         if(features.target_api==VULKAN)
504                 return true;
505         else if(features.target_api==OPENGL_ES)
506         {
507                 if(iface=="uniform")
508                         return check_version(Version(3, 0));
509                 else
510                         return check_version(Version(3, 20));
511         }
512         else if(check_version(Version(1, 50)))
513                 return true;
514         else if(iface=="uniform")
515                 return check_extension(&Features::arb_uniform_buffer_object);
516         else
517                 return false;
518 }
519
520 void StructuralFeatureConverter::visit(InterfaceBlock &iface)
521 {
522         bool push_constant = has_layout_qualifier(iface.layout.get(), "push_constant");
523         if((!supports_interface_blocks(iface.interface) || (push_constant && features.target_api!=VULKAN)) && iface.type_declaration)
524         {
525                 if(!iface.instance_name.empty())
526                         unsupported("ARB_uniform_buffer_object required for interface block instances");
527                 else if(iface.struct_declaration)
528                 {
529                         for(const RefPtr<Statement> &s: iface.struct_declaration->members.body)
530                                 if(VariableDeclaration *var = dynamic_cast<VariableDeclaration *>(s.get()))
531                                         var->interface = iface.interface;
532                         stage->content.body.splice(uniform_insert_point, iface.struct_declaration->members.body);
533                         nodes_to_remove.insert(&iface);
534                         nodes_to_remove.insert(iface.struct_declaration);
535                 }
536                 else
537                         /* If the interface block is an array, it should have an instance
538                         name too, so this should never be reached */
539                         throw logic_error("Unexpected interface block configuration");
540         }
541 }
542
543
544 void QualifierConverter::apply()
545 {
546         stage->content.visit(*this);
547 }
548
549 bool QualifierConverter::supports_interface_layouts() const
550 {
551         if(features.target_api==VULKAN)
552                 return true;
553         else if(features.target_api==OPENGL_ES)
554                 return check_version(Version(3, 0));
555         else if(check_version(Version(3, 30)))
556                 return true;
557         else if(check_version(Version(1, 30)))
558                 return check_extension(&Features::arb_explicit_attrib_location);
559         else
560                 return false;
561 }
562
563 bool QualifierConverter::supports_stage_interface_layouts() const
564 {
565         if(features.target_api==VULKAN)
566                 return true;
567         else if(features.target_api==OPENGL_ES)
568                 return check_version(Version(3, 10));
569         else if(check_version(Version(4, 10)))
570                 return true;
571         else
572                 return check_extension(&Features::arb_separate_shader_objects);
573 }
574
575 bool QualifierConverter::supports_centroid_sampling() const
576 {
577         if(features.target_api==VULKAN)
578                 return true;
579         else if(features.target_api==OPENGL_ES)
580                 return check_version(Version(3, 0));
581         else if(check_version(Version(1, 20)))
582                 return true;
583         else
584                 return check_extension(&Features::ext_gpu_shader4);
585 }
586
587 bool QualifierConverter::supports_sample_sampling() const
588 {
589         if(features.target_api==VULKAN)
590                 return true;
591         else if(features.target_api==OPENGL_ES)
592                 return check_version(Version(3, 20));
593         else if(check_version(Version(4, 0)))
594                 return true;
595         else
596                 return check_extension(&Features::arb_gpu_shader5);
597 }
598
599 bool QualifierConverter::supports_uniform_location() const
600 {
601         if(features.target_api==VULKAN)
602                 return true;
603         else if(features.target_api==OPENGL_ES)
604                 return check_version(Version(3, 10));
605         else if(check_version(Version(4, 30)))
606                 return true;
607         else
608                 return check_extension(&Features::arb_explicit_uniform_location);
609 }
610
611 bool QualifierConverter::supports_binding() const
612 {
613         if(features.target_api==VULKAN)
614                 return true;
615         else if(features.target_api==OPENGL_ES)
616                 return check_version(Version(3, 10));
617         else
618                 return check_version(Version(4, 20));
619 }
620
621 void QualifierConverter::visit(VariableDeclaration &var)
622 {
623         if(var.layout)
624         {
625                 for(auto i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); )
626                 {
627                         if(i->name=="location")
628                         {
629                                 bool supported = true;
630                                 bool external = false;
631                                 if(var.interface=="in")
632                                 {
633                                         external = (stage->type==Stage::VERTEX);
634                                         supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
635                                 }
636                                 else if(var.interface=="out")
637                                 {
638                                         external = (stage->type==Stage::FRAGMENT);
639                                         supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
640                                         if(external && !supported && !check_extension(&Features::ext_gpu_shader4))
641                                         {
642                                                 external = false;
643                                                 if(i->value!=0)
644                                                         unsupported("EXT_gpu_shader4 required for multiple fragment shader outputs");
645                                         }
646                                 }
647                                 else if(var.interface=="uniform")
648                                         supported = supports_uniform_location();
649
650                                 if(!supported)
651                                 {
652                                         if(external)
653                                                 stage->locations[var.name] = i->value;
654                                         i = var.layout->qualifiers.erase(i);
655                                 }
656                                 else
657                                         ++i;
658                         }
659                         else if(i->name=="binding" && !supports_binding())
660                         {
661                                 if(dynamic_cast<const ImageTypeDeclaration *>(get_ultimate_base_type(var.type_declaration)))
662                                         stage->texture_bindings[var.name] = i->value;
663
664                                 i = var.layout->qualifiers.erase(i);
665                         }
666                         else
667                                 ++i;
668                 }
669
670                 if(var.layout->qualifiers.empty())
671                         var.layout = 0;
672         }
673
674         if(var.sampling=="centroid")
675         {
676                 if(!supports_centroid_sampling())
677                         var.sampling = string();
678         }
679         else if(var.sampling=="sample")
680         {
681                 if(!supports_sample_sampling())
682                         var.sampling = string();
683         }
684
685         if(var.name=="gl_ClipDistance")
686                 if(const Literal *literal_size = dynamic_cast<const Literal *>(var.array_size.get()))
687                         stage->n_clip_distances = literal_size->value.value<int>();
688
689         TraversingVisitor::visit(var);
690 }
691
692 bool QualifierConverter::supports_interface_block_location() const
693 {
694         if(features.target_api==VULKAN)
695                 return true;
696         else if(features.target_api==OPENGL_ES)
697                 return check_version(Version(3, 20));
698         else if(check_version(Version(4, 40)))
699                 return true;
700         else
701                 return check_extension(&Features::arb_enhanced_layouts);
702 }
703
704 void QualifierConverter::visit(InterfaceBlock &iface)
705 {
706         if(iface.layout)
707         {
708                 for(auto i=iface.layout->qualifiers.begin(); i!=iface.layout->qualifiers.end(); )
709                 {
710                         if(i->name=="location" && !supports_interface_block_location())
711                                 i = iface.layout->qualifiers.erase(i);
712                         else if(i->name=="binding" && !supports_binding())
713                         {
714                                 stage->uniform_block_bindings[iface.block_name] = i->value;
715                                 i = iface.layout->qualifiers.erase(i);
716                         }
717                         else
718                                 ++i;
719                 }
720
721                 if(iface.layout->qualifiers.empty())
722                         iface.layout = 0;
723         }
724 }
725
726 } // namespace SL
727 } // namespace GL
728 } // namespace Msp