#include <msp/core/algorithm.h>
+#include <msp/core/hash.h>
#include <msp/core/raii.h>
#include <msp/strings/lexicalcast.h>
#include "finalize.h"
namespace GL {
namespace SL {
-void LocationAllocator::apply(Module &module)
+StructOrganizer::StructOrganizer():
+ offset(-1)
+{ }
+
+void StructOrganizer::visit(StructDeclaration &strct)
+{
+ SetForScope<int> set_offset(offset, 0);
+ TraversingVisitor::visit(strct);
+}
+
+void StructOrganizer::visit(VariableDeclaration &var)
+{
+ if(offset>=0)
+ {
+ int *layout_offset = 0;
+ if(var.layout)
+ {
+ vector<Layout::Qualifier> &qualifiers = var.layout->qualifiers;
+ for(vector<Layout::Qualifier>::iterator i=qualifiers.begin(); i!=qualifiers.end(); ++i)
+ if(i->name=="offset" && i->has_value)
+ {
+ layout_offset = &i->value;
+ if(i->value>=offset)
+ offset = i->value;
+ break;
+ }
+ }
+
+ MemoryRequirementsCalculator::Result mem_reqs = MemoryRequirementsCalculator().apply(var);
+ offset += mem_reqs.alignment-1;
+ offset -= offset%mem_reqs.alignment;
+
+ if(layout_offset)
+ *layout_offset = offset;
+ else
+ {
+ if(!var.layout)
+ var.layout = new Layout;
+
+ Layout::Qualifier qual;
+ qual.name = "offset";
+ qual.has_value = true;
+ qual.value = offset;
+ var.layout->qualifiers.push_back(qual);
+ }
+
+ offset += mem_reqs.size;
+ }
+}
+
+
+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)
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;
}
}
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);
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);
{
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)
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);
+ }
}
return check_extension(&Features::arb_explicit_uniform_location);
}
+bool LegacyConverter::supports_binding() const
+{
+ if(features.gl_api==OPENGL_ES2)
+ return check_version(Version(3, 10));
+ else
+ return check_version(Version(4, 20));
+}
+
void LegacyConverter::visit(VariableDeclaration &var)
{
if(var.layout)
else
++i;
}
+ else if(i->name=="binding" && !supports_binding())
+ {
+ 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))
+ stage->texture_bindings[var.name] = i->value;
+
+ i = var.layout->qualifiers.erase(i);
+ }
else
++i;
}
{
if(i->name=="location" && !supports_interface_block_location())
i = iface.layout->qualifiers.erase(i);
+ else if(i->name=="binding" && !supports_binding())
+ {
+ stage->uniform_block_bindings[iface.block_name] = i->value;
+ i = iface.layout->qualifiers.erase(i);
+ }
else
++i;
}
projects / libs / gl.git / blobdiff