#include <msp/core/raii.h>
+#include <msp/gl/extensions/ext_gpu_shader4.h>
#include <msp/strings/format.h>
#include <msp/strings/utils.h>
#include "error.h"
namespace {
const char builtins_src[] =
- "////// vertex\n"
+ "#pragma MSP stage(vertex)\n"
"out gl_PerVertex {\n"
" vec4 gl_Position;\n"
" float gl_ClipDistance[];\n"
- "};"
- "////// geometry\n"
+ "};\n"
+ "#pragma MSP stage(geometry)\n"
"in gl_PerVertex {\n"
" vec4 gl_Position;\n"
" float gl_ClipDistance[];\n"
module(0)
{ }
-void ProgramCompiler::compile(const string &source)
+ProgramCompiler::~ProgramCompiler()
+{
+ delete module;
+}
+
+void ProgramCompiler::compile(const string &source, const string &src_name)
{
resources = 0;
- module = &parser.parse(source);
+ delete module;
+ module = new Module();
+ ProgramParser parser;
+ imported_names.insert(src_name);
+ append_module(parser.parse(source, src_name));
process();
}
-void ProgramCompiler::compile(IO::Base &io, Resources *res)
+void ProgramCompiler::compile(IO::Base &io, Resources *res, const string &src_name)
{
resources = res;
- module = &parser.parse(io);
+ delete module;
+ module = new Module();
+ ProgramParser parser;
+ imported_names.insert(src_name);
+ append_module(parser.parse(io, src_name));
process();
}
+void ProgramCompiler::compile(IO::Base &io, const string &src_name)
+{
+ compile(io, 0, src_name);
+}
+
void ProgramCompiler::add_shaders(Program &program)
{
if(!module)
else if(i->type==FRAGMENT)
{
program.attach_shader_owned(new FragmentShader(apply<Formatter>(*i)));
- for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
- program.bind_fragment_data(j->second, j->first);
+ if(EXT_gpu_shader4)
+ {
+ for(map<string, unsigned>::iterator j=i->locations.begin(); j!=i->locations.end(); ++j)
+ program.bind_fragment_data(j->second, j->first);
+ }
}
}
}
Module *ProgramCompiler::create_builtins_module()
{
ProgramParser parser;
- Module *module = new Module(parser.parse(builtins_src));
+ Module *module = new Module(parser.parse(builtins_src, "<builtin>"));
for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
{
VariableResolver resolver;
return 0;
}
-void ProgramCompiler::process()
+void ProgramCompiler::append_module(ProgramSyntax::Module &mod)
{
- list<Import *> imports = apply<NodeGatherer<Import> >(module->shared);
- for(list<Import *>::iterator i=imports.end(); i!=imports.begin(); )
- import((*--i)->module);
- apply<NodeRemover>(module->shared, set<Node *>(imports.begin(), imports.end()));
+ list<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
+ for(list<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
+ import((*i)->module);
+ apply<NodeRemover>(mod.shared, set<Node *>(imports.begin(), imports.end()));
+ append_stage(mod.shared);
+ for(list<Stage>::iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i)
+ append_stage(*i);
+}
+
+void ProgramCompiler::append_stage(Stage &stage)
+{
+ Stage *target = 0;
+ if(stage.type==SHARED)
+ target = &module->shared;
+ else
+ {
+ list<Stage>::iterator i;
+ for(i=module->stages.begin(); (i!=module->stages.end() && i->type<stage.type); ++i) ;
+ if(i==module->stages.end() || i->type>stage.type)
+ {
+ list<Stage>::iterator j = module->stages.insert(i, stage.type);
+ if(i!=module->stages.end())
+ i->previous = &*j;
+ i = j;
+ if(i!=module->stages.begin())
+ i->previous = &*--j;
+ }
+
+ target = &*i;
+ }
+
+ for(NodeList<Node>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
+ target->content.body.push_back(*i);
+ apply<DeclarationCombiner>(*target);
+}
+
+void ProgramCompiler::process()
+{
for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
generate(*i);
for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); )
void ProgramCompiler::import(const string &name)
{
string fn = name+".glsl";
+ if(imported_names.count(fn))
+ return;
+ imported_names.insert(fn);
+
RefPtr<IO::Seekable> io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn));
if(!io)
throw runtime_error(format("module %s not found", name));
ProgramParser import_parser;
- Module &imported_module = import_parser.parse(*io);
-
- inject_block(module->shared.content, imported_module.shared.content);
- apply<DeclarationCombiner>(module->shared);
- for(list<Stage>::iterator i=imported_module.stages.begin(); i!=imported_module.stages.end(); ++i)
- {
- list<Stage>::iterator j;
- for(j=module->stages.begin(); (j!=module->stages.end() && j->type<i->type); ++j) ;
- if(j==module->stages.end() || j->type>i->type)
- {
- j = module->stages.insert(j, *i);
- list<Stage>::iterator k = j;
- if(++k!=module->stages.end())
- k->previous = &*j;
- if(j!=module->stages.begin())
- j->previous = &*--(k=j);
- }
- else
- {
- inject_block(j->content, i->content);
- apply<DeclarationCombiner>(*j);
- }
- }
+ append_module(import_parser.parse(*io, fn));
}
void ProgramCompiler::generate(Stage &stage)
apply<VariableResolver>(stage);
apply<InterfaceGenerator>(stage);
apply<VariableResolver>(stage);
- apply<VariableRenamer>(stage);
apply<DeclarationReorderer>(stage);
apply<LegacyConverter>(stage);
}
}
+ProgramCompiler::BlockModifier::BlockModifier():
+ remove_node(false)
+{ }
+
+void ProgramCompiler::BlockModifier::flatten_block(Block &block)
+{
+ insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
+ remove_node = true;
+}
+
+void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
+{
+ block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
+ insert_nodes.clear();
+
+ if(remove_node)
+ block.body.erase(i++);
+ else
+ ++i;
+ remove_node = false;
+}
+
+void ProgramCompiler::BlockModifier::visit(Block &block)
+{
+ for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ {
+ (*i)->visit(*this);
+ apply_and_increment(block, i);
+ }
+}
+
+
ProgramCompiler::Formatter::Formatter():
indent(0),
parameter_list(false),
ProgramCompiler::DeclarationCombiner::DeclarationCombiner():
- toplevel(true),
- remove_node(false)
+ toplevel(true)
{ }
void ProgramCompiler::DeclarationCombiner::visit(Block &block)
return;
SetForScope<bool> set(toplevel, false);
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
- {
- remove_node = false;
- (*i)->visit(*this);
- if(remove_node)
- block.body.erase(i++);
- else
- ++i;
- }
+ BlockModifier::visit(block);
}
void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func)
}
-ProgramCompiler::BlockModifier::BlockModifier():
- remove_node(false)
-{ }
-
-void ProgramCompiler::BlockModifier::flatten_block(Block &block)
-{
- insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end());
- remove_node = true;
-}
-
-void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
-{
- block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
- insert_nodes.clear();
-
- if(remove_node)
- block.body.erase(i++);
- else
- ++i;
- remove_node = false;
-}
-
-void ProgramCompiler::BlockModifier::visit(Block &block)
-{
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
- {
- (*i)->visit(*this);
- apply_and_increment(block, i);
- }
-}
-
-
ProgramCompiler::InterfaceGenerator::InterfaceGenerator():
scope_level(0)
{ }
ExpressionStatement *stmt = new ExpressionStatement;
stmt->expression = assign;
+ stmt->visit(*this);
insert_nodes.push_back(stmt);
}
if(i==prev_out.end())
i = prev_out.find(in_prefix+var.name);
if(i!=prev_out.end())
- generate_interface(*i->second, "in", var.name);
+ {
+ generate_interface(*i->second, "in", i->second->name);
+ var.name = i->second->name;
+ }
}
void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
{
remove_node = true;
if(var.init_expression)
+ {
insert_assignment(var.name, var.init_expression->clone());
+ return;
+ }
}
}
else if(var.interface=="in")
}
-void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
-{
- if(var.declaration)
- var.name = var.declaration->name;
-}
-
-void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
-{
- if(var.linked_declaration)
- var.name = var.linked_declaration->name;
- TraversingVisitor::visit(var);
-}
-
-
ProgramCompiler::DeclarationReorderer::DeclarationReorderer():
kind(NO_DECLARATION)
{ }
}
else if(stage->type==FRAGMENT && var.interface=="out")
{
+ if(location!=0)
+ static Require _req(EXT_gpu_shader4);
stage->locations[var.name] = location;
var.layout->qualifiers.erase(i);
}