Improve compatibility checks of location qualifiers in various contexts

[libs/gl.git] / source / glsl / finalize.cpp

diff --git a/source/glsl/finalize.cpp b/source/glsl/finalize.cpp
index 030cb432a4a0c835b2485773ffa8b92fb36b705d..0adb2960b1da3784a4554d9a97b447b12163481d 100644 (file)
--- a/source/glsl/finalize.cpp
+++ b/source/glsl/finalize.cpp
@@ -234,6 +234,16 @@ bool LegacyConverter::supports_interface_layouts() const
                return false;
 }
 
+bool LegacyConverter::supports_stage_interface_layouts() const
+{
+       if(features.gl_api==OPENGL_ES2)
+               return check_version(Version(3, 10));
+       else if(check_version(Version(4, 10)))
+               return true;
+       else
+               return check_extension(&Features::arb_separate_shader_objects);
+}
+
 bool LegacyConverter::supports_centroid_sampling() const
 {
        if(features.gl_api==OPENGL_ES2)
@@ -254,25 +264,53 @@ bool LegacyConverter::supports_sample_sampling() const
                return check_extension(&Features::arb_gpu_shader5);
 }
 
+bool LegacyConverter::supports_uniform_location() const
+{
+       if(features.gl_api==OPENGL_ES2)
+               return check_version(Version(3, 10));
+       else if(check_version(Version(4, 30)))
+               return true;
+       else
+               return check_extension(&Features::arb_explicit_uniform_location);
+}
+
 void LegacyConverter::visit(VariableDeclaration &var)
 {
        if(var.layout)
        {
                for(vector<Layout::Qualifier>::const_iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); )
                {
-                       if(i->name=="location" && !supports_interface_layouts())
+                       if(i->name=="location")
                        {
-                               if(stage->type==Stage::VERTEX && var.interface=="in")
-                                       stage->locations[var.name] = i->value;
-                               else if(stage->type==Stage::FRAGMENT && var.interface=="out")
+                               bool supported = true;
+                               bool external = false;
+                               if(var.interface=="in")
                                {
-                                       if(check_extension(&Features::ext_gpu_shader4))
-                                               stage->locations[var.name] = i->value;
-                                       else if(i->value!=0)
-                                               unsupported("EXT_gpu_shader4 required for multiple fragment shader outputs");
+                                       external = (stage->type==Stage::VERTEX);
+                                       supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
                                }
+                               else if(var.interface=="out")
+                               {
+                                       external = (stage->type==Stage::FRAGMENT);
+                                       supported = (external ? supports_interface_layouts() : supports_stage_interface_layouts());
+                                       if(external && !supported && !check_extension(&Features::ext_gpu_shader4))
+                                       {
+                                               external = false;
+                                               if(i->value!=0)
+                                                       unsupported("EXT_gpu_shader4 required for multiple fragment shader outputs");
+                                       }
+                               }
+                               else if(var.interface=="uniform")
+                                       supported = supports_uniform_location();
 
-                               i = var.layout->qualifiers.erase(i);
+                               if(!supported)
+                               {
+                                       if(external)
+                                               stage->locations[var.name] = i->value;
+                                       i = var.layout->qualifiers.erase(i);
+                               }
+                               else
+                                       ++i;
                        }
                        else
                                ++i;
@@ -322,8 +360,32 @@ bool LegacyConverter::supports_interface_blocks(const string &iface) const
                return false;
 }
 
+bool LegacyConverter::supports_interface_block_location() const
+{
+       if(features.gl_api==OPENGL_ES2)
+               return check_version(Version(3, 20));
+       else if(check_version(Version(4, 40)))
+               return true;
+       else
+               return check_extension(&Features::arb_enhanced_layouts);
+}
+
 void LegacyConverter::visit(InterfaceBlock &iface)
 {
+       if(iface.layout)
+       {
+               for(vector<Layout::Qualifier>::const_iterator i=iface.layout->qualifiers.begin(); i!=iface.layout->qualifiers.end(); )
+               {
+                       if(i->name=="location" && !supports_interface_block_location())
+                               i = iface.layout->qualifiers.erase(i);
+                       else
+                               ++i;
+               }
+
+               if(iface.layout->qualifiers.empty())
+                       iface.layout = 0;
+       }
+
        if(!supports_interface_blocks(iface.interface) && iface.type_declaration)
        {
                if(!iface.instance_name.empty())