+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;
+ bool has_matrix_order = false;
+ if(var.layout)
+ {
+ for(Layout::Qualifier &q: var.layout->qualifiers)
+ {
+ if(q.name=="offset" && q.has_value)
+ {
+ layout_offset = &q.value;
+ if(q.value>=offset)
+ offset = q.value;
+ }
+ else if(q.name=="column_major" || q.name=="row_major")
+ has_matrix_order = true;
+ }
+ }
+
+ MemoryRequirementsCalculator::Result mem_reqs = MemoryRequirementsCalculator().apply(var);
+ offset += mem_reqs.alignment-1;
+ offset -= offset%mem_reqs.alignment;
+
+ if(layout_offset)
+ *layout_offset = offset;
+ else
+ add_layout_qualifier(var.layout, Layout::Qualifier("offset", offset));
+
+ if(!has_matrix_order)
+ {
+ const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(var.type_declaration);
+ while(basic && basic->kind==BasicTypeDeclaration::ARRAY)
+ basic = dynamic_cast<const BasicTypeDeclaration *>(basic->base_type);
+ if(basic && basic->kind==BasicTypeDeclaration::MATRIX)
+ add_layout_qualifier(var.layout, Layout::Qualifier("column_major"));
+ }
+
+ offset += mem_reqs.size;
+ }
+}
+
+
+void LocationAllocator::apply(Module &module, const Features &f, bool a)
+{
+ features = f;
+ alloc_new = a;
+ for(Stage &s: module.stages)
+ apply(s);
+
+ if(features.target_api!=VULKAN)
+ allocate_locations("uniform");
+
+ for(VariableDeclaration *b: unbound_blocks)
+ bind_uniform(b->layout, b->block_declaration->block_name, features.uniform_binding_range);
+ for(VariableDeclaration *t: unbound_textures)
+ bind_uniform(t->layout, t->name, features.texture_binding_range);
+}
+
+void LocationAllocator::apply(Stage &stage)
+{
+ swap(used_locations["in"], used_locations["out"]);
+ used_locations["out"].clear();
+
+ stage.content.visit(*this);
+
+ allocate_locations("in");
+ allocate_locations("out");
+}
+
+void LocationAllocator::allocate_locations(const string &iface)
+{
+ auto write = unplaced_variables.begin();
+ unsigned next = 0;
+ for(auto i=unplaced_variables.begin(); i!=unplaced_variables.end(); ++i)
+ {
+ if((*i)->interface!=iface)
+ {
+ if(write!=i)
+ *write = *i;
+ ++write;
+ continue;
+ }
+
+ if((*i)->interface=="uniform")
+ {
+ auto j = uniforms.find((*i)->name);
+ if(j!=uniforms.end() && j->second.location>=0)
+ {
+ add_layout_qualifier((*i)->layout, Layout::Qualifier("location", j->second.location));
+ continue;
+ }
+ }
+
+ if(!alloc_new)
+ continue;
+
+ set<unsigned> &used = used_locations[(*i)->interface];
+
+ unsigned size = LocationCounter().apply(**i);
+ while(1)
+ {
+ int blocking = -1;
+ for(unsigned j=0; j<size; ++j)
+ if(used.count(next+j))
+ blocking = next+j;
+ if(blocking<0)
+ break;
+ next = blocking+1;
+ }
+
+ add_layout_qualifier((*i)->layout, Layout::Qualifier("location", next));
+ if((*i)->interface=="uniform")
+ uniforms[(*i)->name].location = next;
+
+ for(unsigned j=0; j<size; ++j)
+ used.insert(next+j);
+ next += size;
+ }
+
+ unplaced_variables.erase(write, unplaced_variables.end());
+}
+
+void LocationAllocator::bind_uniform(RefPtr<Layout> &layout, const string &name, unsigned range)
+{
+ auto i = uniforms.find(name);
+
+ int desc_set = (i!=uniforms.end() ? i->second.desc_set : 0);
+ if(features.target_api==VULKAN && get_layout_value(layout.get(), "set")<0)
+ add_layout_qualifier(layout, Layout::Qualifier("set", desc_set));
+
+ if(i!=uniforms.end() && i->second.bind_point>=0)
+ add_layout_qualifier(layout, Layout::Qualifier("binding", i->second.bind_point));
+ else if(alloc_new)
+ {
+ set<unsigned> &used = used_bindings[desc_set];
+
+ unsigned bind_point = hash_fold<32>(hash<64>(name))%range;
+ while(used.count(bind_point))
+ bind_point = (bind_point+1)%range;
+
+ add_layout_qualifier(layout, Layout::Qualifier("binding", bind_point));
+ uniforms[name].bind_point = bind_point;
+ used.insert(bind_point);
+ }
+}
+
+bool LocationAllocator::visit_uniform(const string &name, RefPtr<Layout> &layout)
+{
+ int desc_set = 0;
+ int bind_point = get_layout_value(layout.get(), "binding");
+
+ if(features.target_api==VULKAN)
+ {
+ desc_set = get_layout_value(layout.get(), "set");
+ if(desc_set<0 && bind_point>=0)
+ {
+ desc_set = 0;
+ add_layout_qualifier(layout, Layout::Qualifier("set", desc_set));
+ }
+
+ if(desc_set>=0)
+ uniforms[name].desc_set = desc_set;
+ }
+
+ if(bind_point>=0)
+ {
+ used_bindings[desc_set].insert(bind_point);
+ uniforms[name].bind_point = bind_point;
+ }
+
+ return bind_point>=0;
+}
+
+void LocationAllocator::visit(VariableDeclaration &var)
+{
+ if(!var.name.compare(0, 3, "gl_"))
+ return;
+
+ if(!var.interface.empty() && !var.block_declaration)
+ {
+ int location = get_layout_value(var.layout.get(), "location");
+
+ if(location<0 && var.linked_declaration && var.linked_declaration->layout)
+ {
+ location = get_layout_value(var.linked_declaration->layout.get(), "location");
+ if(location>=0)
+ add_layout_qualifier(var.layout, Layout::Qualifier("location", location));
+ }
+
+ if(location>=0)
+ {
+ unsigned size = LocationCounter().apply(var);
+ for(unsigned i=0; i<size; ++i)
+ used_locations[var.interface].insert(location+i);
+ if(var.interface=="uniform")
+ uniforms[var.name].location = location;
+ }
+ else
+ unplaced_variables.push_back(&var);
+ }
+
+ if(var.interface=="uniform")
+ {
+ if(var.block_declaration)
+ {
+ bool push_constant = has_layout_qualifier(var.layout.get(), "push_constant");
+ if(!push_constant && !visit_uniform(var.block_declaration->block_name, var.layout))
+ unbound_blocks.push_back(&var);
+ }
+ else
+ {
+ const TypeDeclaration *base_type = get_ultimate_base_type(var.type_declaration);
+ if(dynamic_cast<const ImageTypeDeclaration *>(base_type) && !visit_uniform(var.name, var.layout))
+ unbound_textures.push_back(&var);
+ }
+ }
+}
+
+
+void DepthRangeConverter::apply(Stage &stage, const Features &features)
+{
+ if(stage.type!=Stage::VERTEX || features.target_api==VULKAN)
+ return;
+
+ stage.content.visit(*this);
+}
+
+void DepthRangeConverter::visit(FunctionDeclaration &func)
+{
+ if(func.definition==&func && func.name=="main")
+ {
+ VariableReference *position = new VariableReference;
+ position->name = "gl_Position";
+
+ MemberAccess *z = new MemberAccess;
+ z->left = position;
+ z->member = "z";
+
+ Literal *scale = new Literal;
+ scale->token = "2.0";
+ scale->value = 2.0f;
+
+ BinaryExpression *multiply = new BinaryExpression;
+ multiply->oper = &Operator::get_operator("*", Operator::BINARY);
+ multiply->left = z;
+ multiply->right = scale;
+
+ MemberAccess *w = new MemberAccess;
+ w->left = position->clone();
+ w->member = "w";
+
+ BinaryExpression *subtract = new BinaryExpression;
+ subtract->oper = &Operator::get_operator("-", Operator::BINARY);
+ subtract->left = multiply;
+ subtract->right = w;
+
+ Assignment *assign = new Assignment;
+ assign->oper = &Operator::get_operator("=", Operator::BINARY);
+ assign->left = z->clone();
+ assign->right = subtract;
+
+ ExpressionStatement *statement = new ExpressionStatement;
+ statement->expression = assign;
+
+ func.body.body.push_back(statement);
+ }
+}
+