X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.h;h=d303af3664b3294c74209b6dce738b999c8213ff;hb=4c805f55d89919d6971d600102ab4d6d65d56dc3;hp=f1f10b897c281e9ec4a39ff032a167963b936b8a;hpb=7daccf2582084283a9e5064995f674eef835996e;p=libs%2Fgl.git diff --git a/source/glsl/generate.h b/source/glsl/generate.h index f1f10b89..d303af36 100644 --- a/source/glsl/generate.h +++ b/source/glsl/generate.h @@ -11,6 +11,7 @@ namespace Msp { namespace GL { namespace SL { +/** Combines multiple declarations of the same identifier into one. */ class DeclarationCombiner: private TraversingVisitor { private: @@ -23,11 +24,29 @@ public: private: virtual void visit(Block &); - virtual void visit(FunctionDeclaration &); + virtual void visit(VariableDeclaration &); + virtual void visit(FunctionDeclaration &) { } +}; + +/** Manipulates specialization constants. If values are specified, turns +specialization constants into normal constants. Without values assigns +automatic constant_ids to specialization constants. */ +class ConstantSpecializer: private TraversingVisitor +{ +private: + const std::map *values; + +public: + ConstantSpecializer(); + + void apply(Stage &, const std::map *); + +private: virtual void visit(VariableDeclaration &); }; -class BlockResolver: private TraversingVisitor +/** Forms links between nested blocks in the syntax tree. */ +class BlockHierarchyResolver: private TraversingVisitor { public: void apply(Stage &s) { s.content.visit(*this); } @@ -36,17 +55,36 @@ private: virtual void enter(Block &); }; +/** Resolves types of variables and base types of other types. */ +class TypeResolver: private TraversingVisitor +{ +private: + Stage *stage; + +public: + TypeResolver(); + + void apply(Stage &); + +private: + virtual void visit(BasicTypeDeclaration &); + virtual void visit(ImageTypeDeclaration &); + virtual void visit(StructDeclaration &); + virtual void visit(VariableDeclaration &); +}; + +/** Resolves variable references. Variable references which match the name +of an interface block are turned into interface block references. */ class VariableResolver: private TraversingVisitor { private: Stage *stage; - Block *builtins; - std::map *members; - RefPtr iface_ref; + std::map *r_members; + RefPtr r_iface_ref; std::string block_interface; bool record_target; - VariableDeclaration *assignment_target; - bool self_referencing; + bool r_self_referencing; + VariableDeclaration *r_assignment_target; public: VariableResolver(); @@ -54,32 +92,41 @@ public: void apply(Stage &); private: - Block *next_block(Block &); - virtual void enter(Block &); virtual void visit(VariableReference &); virtual void visit(InterfaceBlockReference &); virtual void visit(MemberAccess &); + virtual void visit(UnaryExpression &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); - virtual void visit(StructDeclaration &); + virtual void visit(FunctionCall &); virtual void visit(VariableDeclaration &); virtual void visit(InterfaceBlock &); }; +/** Resolves function declarations and calls. */ class FunctionResolver: private TraversingVisitor { private: - std::map > functions; + Stage *stage; + std::map > declarations; public: - void apply(Stage &s) { s.content.visit(*this); } + void apply(Stage &); private: virtual void visit(FunctionCall &); virtual void visit(FunctionDeclaration &); }; +/** Materializes implicitly declared interfaces. + +Out variable declarations inside functions are moved to the global scope. + +Passthrough statements are processed, generating out variables to match in +variables and copying values. + +Unresolved variables are looked up in the previous stage's out variables. */ class InterfaceGenerator: private TraversingVisitor { private: @@ -103,8 +150,8 @@ private: static std::string get_out_prefix(Stage::Type); std::string change_prefix(const std::string &, const std::string &) const; virtual void visit(Block &); - bool generate_interface(VariableDeclaration &, const std::string &, const std::string &); - bool generate_interface(InterfaceBlock &); + VariableDeclaration *generate_interface(VariableDeclaration &, const std::string &, const std::string &); + InterfaceBlock *generate_interface(InterfaceBlock &); ExpressionStatement &insert_assignment(const std::string &, Expression *); virtual void visit(VariableReference &); virtual void visit(VariableDeclaration &); @@ -113,37 +160,6 @@ private: virtual void visit(Passthrough &); }; -class DeclarationReorderer: private TraversingVisitor -{ -private: - enum DeclarationKind - { - NO_DECLARATION, - LAYOUT, - STRUCT, - VARIABLE, - FUNCTION - }; - - DeclarationKind kind; - std::set ordered_funcs; - std::set needed_funcs; - -public: - DeclarationReorderer(); - - void apply(Stage &s) { s.content.visit(*this); } - -private: - virtual void visit(Block &); - virtual void visit(FunctionCall &); - virtual void visit(InterfaceLayout &) { kind = LAYOUT; } - virtual void visit(StructDeclaration &) { kind = STRUCT; } - virtual void visit(VariableDeclaration &); - virtual void visit(InterfaceBlock &) { kind = VARIABLE; } - virtual void visit(FunctionDeclaration &); -}; - } // namespace SL } // namespace GL } // namespace Msp