Assign bindings to all uniform blocks and sampler uniforms

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

diff --git a/source/glsl/finalize.cpp b/source/glsl/finalize.cpp
index 1b300e72a872cd55aa19727cf284efba5607b26f..2d1a46fb0862639457a1137a2de94036c6a1f7da 100644 (file)
--- a/source/glsl/finalize.cpp
+++ b/source/glsl/finalize.cpp
@@ -1,4 +1,5 @@
 #include <msp/core/algorithm.h>
+#include <msp/core/hash.h>
 #include <msp/core/raii.h>
 #include <msp/strings/lexicalcast.h>
 #include "finalize.h"
@@ -11,11 +12,16 @@ namespace Msp {
 namespace GL {
 namespace SL {
 
-void LocationAllocator::apply(Module &module)
+void LocationAllocator::apply(Module &module, const Features &features)
 {
        for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
                apply(*i);
        allocate_locations("uniform");
+
+       for(vector<InterfaceBlock *>::const_iterator i=unbound_blocks.begin(); i!=unbound_blocks.end(); ++i)
+               bind_uniform((*i)->layout, (*i)->block_name, features.uniform_binding_range);
+       for(vector<VariableDeclaration *>::const_iterator i=unbound_textures.begin(); i!=unbound_textures.end(); ++i)
+               bind_uniform((*i)->layout, (*i)->name, features.texture_binding_range);
 }
 
 void LocationAllocator::apply(Stage &stage)
@@ -45,10 +51,10 @@ void LocationAllocator::allocate_locations(const string &iface)
 
                if((*i)->interface=="uniform")
                {
-                       map<string, unsigned>::const_iterator j = uniform_locations.find((*i)->name);
-                       if(j!=uniform_locations.end())
+                       map<string, Uniform>::const_iterator j = uniforms.find((*i)->name);
+                       if(j!=uniforms.end() && j->second.location>=0)
                        {
-                               add_location((*i)->layout, j->second);
+                               add_layout_value((*i)->layout, "location", j->second.location);
                                continue;
                        }
                }
@@ -67,9 +73,9 @@ void LocationAllocator::allocate_locations(const string &iface)
                        next = blocking+1;
                }
 
-               add_location((*i)->layout, next);
+               add_layout_value((*i)->layout, "location", next);
                if((*i)->interface=="uniform")
-                       uniform_locations[(*i)->name] = next;
+                       uniforms[(*i)->name].location = next;
 
                for(unsigned j=0; j<size; ++j)
                        used.insert(next+j);
@@ -79,21 +85,43 @@ void LocationAllocator::allocate_locations(const string &iface)
        unplaced_variables.erase(write, unplaced_variables.end());
 }
 
-void LocationAllocator::add_location(RefPtr<Layout> &layout, unsigned location)
+void LocationAllocator::bind_uniform(RefPtr<Layout> &layout, const string &name, unsigned range)
+{
+       map<string, Uniform>::const_iterator i = uniforms.find(name);
+       if(i!=uniforms.end() && i->second.bind_point>=0)
+               add_layout_value(layout, "binding", i->second.bind_point);
+       else
+       {
+               set<unsigned> &used = used_bindings[0];
+
+               unsigned bind_point = fold32(hash64(name))%range;
+               while(used.count(bind_point))
+                       bind_point = (bind_point+1)%range;
+
+               add_layout_value(layout, "binding", bind_point);
+               uniforms[name].bind_point = bind_point;
+               used.insert(bind_point);
+       }
+}
+
+void LocationAllocator::add_layout_value(RefPtr<Layout> &layout, const string &name, unsigned value)
 {
        if(!layout)
                layout = new Layout;
 
        Layout::Qualifier qual;
-       qual.name = "location";
+       qual.name = name;
        qual.has_value = true;
-       qual.value = location;
+       qual.value = value;
        layout->qualifiers.push_back(qual);
 }
 
 void LocationAllocator::visit(VariableDeclaration &var)
 {
-       if(!var.interface.empty() && var.name.compare(0, 3, "gl_"))
+       if(!var.name.compare(0, 3, "gl_"))
+               return;
+
+       if(!var.interface.empty())
        {
                int location = (var.layout ? get_layout_value(*var.layout, "location") : -1);
 
@@ -101,7 +129,7 @@ void LocationAllocator::visit(VariableDeclaration &var)
                {
                        location = get_layout_value(*var.linked_declaration->layout, "location");
                        if(location>=0)
-                               add_location(var.layout, location);
+                               add_layout_value(var.layout, "location", location);
                }
 
                if(location>=0)
@@ -110,11 +138,48 @@ void LocationAllocator::visit(VariableDeclaration &var)
                        for(unsigned i=0; i<size; ++i)
                                used_locations[var.interface].insert(location+i);
                        if(var.interface=="uniform")
-                               uniform_locations[var.name] = location;
+                               uniforms[var.name].location = location;
                }
                else
                        unplaced_variables.push_back(&var);
        }
+
+       if(var.interface=="uniform")
+       {
+               const TypeDeclaration *type = var.type_declaration;
+               while(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
+                       type = basic->base_type;
+               if(dynamic_cast<const ImageTypeDeclaration *>(type))
+               {
+                       int bind_point = (var.layout ? get_layout_value(*var.layout, "binding") : -1);
+                       if(bind_point>=0)
+                       {
+                               used_bindings[0].insert(bind_point);
+                               uniforms[var.name].bind_point = bind_point;
+                       }
+                       else
+                               unbound_textures.push_back(&var);
+               }
+       }
+}
+
+void LocationAllocator::visit(InterfaceBlock &iface)
+{
+       if(!iface.instance_name.compare(0, 3, "gl_"))
+               return;
+
+       if(iface.interface=="uniform")
+       {
+               int bind_point = (iface.layout ? get_layout_value(*iface.layout, "binding") : -1);
+
+               if(bind_point>=0)
+               {
+                       used_bindings[0].insert(bind_point);
+                       uniforms[iface.block_name].bind_point = bind_point;
+               }
+               else
+                       unbound_blocks.push_back(&iface);
+       }
 }