X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=99253fe041463ce01a852f340b967cb744f33a50;hp=ec51c19cdd9cc90472a0b2471eff915823fae0d7;hb=HEAD;hpb=38712d8ecc57d043a2419ffbaeeb57f7a6586f14 diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp index ec51c19c..635d9f15 100644 --- a/source/glsl/generate.cpp +++ b/source/glsl/generate.cpp @@ -2,6 +2,7 @@ #include #include #include "generate.h" +#include "reflect.h" using namespace std; @@ -16,15 +17,23 @@ void ConstantIdAssigner::apply(Module &module, const Features &features) for(VariableDeclaration *v: auto_constants) { - unsigned id = hash32(v->name)%features.constant_id_range; - while(used_ids.count(id)) - id = (id+1)%features.constant_id_range; + unsigned id; + auto j = existing_constants.find(v->name); + if(j!=existing_constants.end()) + id = j->second; + else + { + id = hash<32>(v->name)%features.constant_id_range; + while(used_ids.count(id)) + id = (id+1)%features.constant_id_range; + } auto i = find_member(v->layout->qualifiers, string("constant_id"), &Layout::Qualifier::name); if(i!=v->layout->qualifiers.end()) i->value = id; used_ids.insert(id); + existing_constants[v->name] = id; } } @@ -38,7 +47,10 @@ void ConstantIdAssigner::visit(VariableDeclaration &var) if(i->value==-1) auto_constants.push_back(&var); else + { + existing_constants[var.name] = i->value; used_ids.insert(i->value); + } } } } @@ -89,17 +101,28 @@ VariableDeclaration *InterfaceGenerator::generate_interface(VariableDeclaration if(stage->content.variables.count(name)) return 0; - if(stage->type==Stage::GEOMETRY && !copy_block && var.interface=="out" && var.array) + if(stage->type==Stage::GEOMETRY && var.interface=="out" && var.array) return 0; VariableDeclaration* iface_var = new VariableDeclaration; iface_var->sampling = var.sampling; + if(stage->type==Stage::FRAGMENT && iface=="in") + if(BasicTypeDeclaration *basic = dynamic_cast(var.type_declaration)) + if(BasicTypeDeclaration *elem = get_element_type(*basic)) + if(elem->kind==BasicTypeDeclaration::INT) + iface_var->interpolation = "flat"; iface_var->interface = iface; iface_var->type = var.type; iface_var->name = name; - /* Geometry shader inputs are always arrays. But if we're bringing in an - entire block, the array is on the block and not individual variables. */ - if(stage->type==Stage::GEOMETRY && !copy_block) + // Tessellation and geometry inputs may be arrayed. + if(stage->type==Stage::TESS_CONTROL) + // VS out -> TCS in: add | TCS in -> TCS out: unchanged | VS out -> TCS out: add + iface_var->array = (var.array || var.interface!="in"); + else if(stage->type==Stage::TESS_EVAL) + // TCS out -> TES in: unchanged | TES in -> TES out: remove | TCS out -> TES out: remove + iface_var->array = (var.array && iface=="in"); + else if(stage->type==Stage::GEOMETRY) + // VS/TES out -> GS in: add | GS in -> GS out: remove | VS/TES out -> GS out: unchanged iface_var->array = ((var.array && var.interface!="in") || iface=="in"); else iface_var->array = var.array; @@ -112,6 +135,21 @@ VariableDeclaration *InterfaceGenerator::generate_interface(VariableDeclaration var.linked_declaration = iface_var; } + if(var.block_declaration) + { + StructDeclaration *iface_type = var.block_declaration->clone(); + iface_type->name = format("_%s_%s", iface, var.block_declaration->block_name); + iface_target_block->body.insert(iface_insert_point, iface_type); + + iface_var->type = iface_type->name; + if(name.empty()) + iface_var->name = format("%s %s", iface, var.block_declaration->block_name); + + stage->interface_blocks.insert(make_pair("in "+var.block_declaration->block_name, iface_var)); + if(!name.empty()) + stage->interface_blocks.insert(make_pair(name, iface_var)); + } + iface_target_block->body.insert(iface_insert_point, iface_var); iface_target_block->variables.insert(make_pair(name, iface_var)); if(iface_target_block==&stage->content && iface=="in") @@ -120,51 +158,26 @@ VariableDeclaration *InterfaceGenerator::generate_interface(VariableDeclaration return iface_var; } -InterfaceBlock *InterfaceGenerator::generate_interface(InterfaceBlock &out_block) +ExpressionStatement &InterfaceGenerator::insert_assignment(const string &left, Expression *right) { - if(stage->interface_blocks.count("in "+out_block.block_name)) - return 0; + Assignment *assign = new Assignment; - InterfaceBlock *in_block = new InterfaceBlock; - in_block->interface = "in"; - in_block->block_name = out_block.block_name; - in_block->members = new Block; - in_block->instance_name = out_block.instance_name; - if(stage->type==Stage::GEOMETRY) - in_block->array = true; - else - in_block->array = out_block.array; - in_block->linked_block = &out_block; - out_block.linked_block = in_block; + string::size_type dot = left.find('.'); + VariableReference *ref = new VariableReference; + ref->name = left.substr(0, dot); + assign->left = ref; + while(dot!=string::npos) { - SetFlag set_copy(copy_block, true); - SetForScope set_target(iface_target_block, in_block->members.get()); - SetForScope::iterator> set_ins_pt(iface_insert_point, in_block->members->body.end()); - if(out_block.struct_declaration) - out_block.struct_declaration->members.visit(*this); - else if(out_block.members) - out_block.members->visit(*this); - } + string::size_type start = dot+1; + dot = left.find('.', start); - iface_target_block->body.insert(iface_insert_point, in_block); - stage->interface_blocks.insert(make_pair("in "+in_block->block_name, in_block)); - if(!in_block->instance_name.empty()) - stage->interface_blocks.insert(make_pair(in_block->instance_name, in_block)); - - SetFlag set_scope(function_scope, false); - SetForScope set_block(current_block, &stage->content); - in_block->visit(*this); - - return in_block; -} + MemberAccess *memacc = new MemberAccess; + memacc->left = assign->left; + memacc->member = left.substr(start, dot-start); + assign->left = memacc; + } -ExpressionStatement &InterfaceGenerator::insert_assignment(const string &left, Expression *right) -{ - Assignment *assign = new Assignment; - VariableReference *ref = new VariableReference; - ref->name = left; - assign->left = ref; assign->oper = &Operator::get_operator("=", Operator::BINARY); assign->right = right; @@ -202,24 +215,14 @@ void InterfaceGenerator::visit(VariableReference &var) return; } - const map &prev_blocks = stage->previous->interface_blocks; - auto j = prev_blocks.find(var.name); - if(j!=prev_blocks.end() && j->second->interface=="out") - { - generate_interface(*j->second); - /* Let VariableResolver convert the variable reference into an interface - block reference. */ - return; - } - - for(const auto &kvp: prev_blocks) - if(kvp.second->instance_name.empty() && kvp.second->struct_declaration) + for(const auto &kvp: stage->previous->interface_blocks) + if(kvp.second->name.find(' ')!=string::npos) { - const map &iface_vars = kvp.second->struct_declaration->members.variables; + const map &iface_vars = kvp.second->block_declaration->members.variables; i = iface_vars.find(var.name); if(i!=iface_vars.end()) { - generate_interface(*kvp.second); + generate_interface(*kvp.second, "in", string()); return; } } @@ -227,9 +230,7 @@ void InterfaceGenerator::visit(VariableReference &var) void InterfaceGenerator::visit(VariableDeclaration &var) { - if(copy_block) - generate_interface(var, "in", var.name); - else if(var.interface=="out") + if(var.interface=="out") { /* For output variables in function scope, generate a global interface and replace the local declaration with an assignment. */ @@ -257,38 +258,30 @@ void InterfaceGenerator::visit(VariableDeclaration &var) previous stage. */ if(!var.linked_declaration && stage->previous) { - const map &prev_vars = stage->previous->content.variables; - auto i = prev_vars.find(var.name); - if(i!=prev_vars.end() && i->second->interface=="out") + const map *prev_vars; + string name; + // Blocks are linked by their block name, not instance name + if(var.block_declaration) { - var.linked_declaration = i->second; - i->second->linked_declaration = &var; + prev_vars = &stage->previous->interface_blocks; + name = "out "+var.block_declaration->block_name; + } + else + { + prev_vars = &stage->previous->content.variables; + name = var.name; } - } - } - - TraversingVisitor::visit(var); -} -void InterfaceGenerator::visit(InterfaceBlock &iface) -{ - if(iface.interface=="in") - { - /* Try to link input blocks with output blocks sharing the same block - name from previous stage. */ - if(!iface.linked_block && stage->previous) - { - const map &prev_blocks = stage->previous->interface_blocks; - auto i = prev_blocks.find("out "+iface.block_name); - if(i!=prev_blocks.end()) + auto i = prev_vars->find(name); + if(i!=prev_vars->end() && i->second->interface=="out") { - iface.linked_block = i->second; - i->second->linked_block = &iface; + var.linked_declaration = i->second; + i->second->linked_declaration = &var; } } } - TraversingVisitor::visit(iface); + TraversingVisitor::visit(var); } void InterfaceGenerator::visit(FunctionDeclaration &func) @@ -321,7 +314,7 @@ void InterfaceGenerator::visit(Passthrough &pass) { /* Special case for geometry shader: copy gl_Position from input to output. */ - InterfaceBlockReference *ref = new InterfaceBlockReference; + VariableReference *ref = new VariableReference; ref->name = "gl_in"; BinaryExpression *subscript = new BinaryExpression; @@ -333,7 +326,7 @@ void InterfaceGenerator::visit(Passthrough &pass) memacc->left = subscript; memacc->member = "gl_Position"; - insert_assignment("gl_Position", memacc); + insert_assignment("out gl_PerVertex.gl_Position", memacc); } for(VariableDeclaration *v: pass_vars) @@ -358,6 +351,151 @@ void InterfaceGenerator::visit(Passthrough &pass) nodes_to_remove.insert(&pass); } + +void LayoutDefaulter::apply(Stage &stage) +{ + if(stage.type==Stage::TESS_EVAL) + { + stage.content.visit(*this); + if((need_winding || need_spacing) && in_iface) + { + if(need_winding) + in_iface->layout.qualifiers.emplace_back("ccw"); + if(need_spacing) + in_iface->layout.qualifiers.emplace_back("equal_spacing"); + } + } +} + +void LayoutDefaulter::visit(InterfaceLayout &iface) +{ + if(iface.interface=="in") + { + if(!in_iface) + in_iface = &iface; + for(const Layout::Qualifier &q: iface.layout.qualifiers) + { + if(q.name=="cw" || q.name=="ccw") + need_winding = false; + else if(q.name=="equal_spacing" || q.name=="fractional_even_spacing" || q.name=="fractional_odd_spacing") + need_spacing = false; + } + } +} + + +void ArraySizer::apply(Stage &stage) +{ + stage.content.visit(*this); + for(const auto &kvp: max_indices) + if(kvp.first->array && !kvp.first->array_size) + { + int size = 0; + if(stage.type==Stage::GEOMETRY && kvp.first->interface=="in") + size = input_size; + else if(kvp.second>=0) + size = kvp.second+1; + if(!size && !kvp.first->name.compare(0, 3, "gl_")) + size = 1; + + if(size>0) + { + Literal *literal_size = new Literal; + literal_size->token = lexical_cast(size); + literal_size->value = size; + kvp.first->array_size = literal_size; + } + } +} + +void ArraySizer::visit(VariableReference &var) +{ + r_declaration = var.declaration; +} + +void ArraySizer::visit(MemberAccess &memacc) +{ + r_declaration = 0; + TraversingVisitor::visit(memacc); + VariableDeclaration *member_declaration = 0; + if(r_declaration) + if(StructDeclaration *strct = dynamic_cast(r_declaration->type_declaration)) + { + auto i = strct->members.variables.find(memacc.member); + if(i!=strct->members.variables.end()) + member_declaration = i->second; + } + r_declaration = member_declaration; +} + +void ArraySizer::visit(Swizzle &swizzle) +{ + TraversingVisitor::visit(swizzle); + r_declaration = 0; +} + +void ArraySizer::visit(UnaryExpression &unary) +{ + TraversingVisitor::visit(unary); + r_declaration = 0; +} + +void ArraySizer::visit(BinaryExpression &binary) +{ + if(binary.oper->token[0]=='[') + if(const Literal *literal_index = dynamic_cast(binary.right.get())) + if(literal_index->value.check_type()) + { + r_declaration = 0; + binary.left->visit(*this); + if(r_declaration) + { + max_indices[r_declaration] = literal_index->value.value(); + return; + } + } + + TraversingVisitor::visit(binary); +} + +void ArraySizer::visit(TernaryExpression &ternary) +{ + TraversingVisitor::visit(ternary); + r_declaration = 0; +} + +void ArraySizer::visit(FunctionCall &call) +{ + TraversingVisitor::visit(call); + r_declaration = 0; +} + +void ArraySizer::visit(InterfaceLayout &layout) +{ + if(layout.interface=="in") + { + for(const Layout::Qualifier &q: layout.layout.qualifiers) + { + if(q.name=="points") + input_size = 1; + else if(q.name=="lines") + input_size = 2; + else if(q.name=="triangles") + input_size = 3; + else if(q.name=="lines_adjacency") + input_size = 4; + else if(q.name=="triangles_adjacency") + input_size = 6; + } + } +} + +void ArraySizer::visit(VariableDeclaration &var) +{ + if(var.array && !var.array_size) + max_indices[&var] = 0; +} + } // namespace SL } // namespace GL } // namespace Msp