X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.h;h=a728e99ced3a8bccd24aaa89de94cbbddee09664;hp=4968297635c074e975af19e42934c57fe1da78a7;hb=c1d3a1d7c1997bc71a30af2e2c25cb4a2b66784b;hpb=bd8816692056230c36504dcccd76c6946dff47b1 diff --git a/source/glsl/generate.h b/source/glsl/generate.h index 49682976..a728e99c 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,63 +24,171 @@ public: private: virtual void visit(Block &); - virtual void visit(FunctionDeclaration &); virtual void visit(VariableDeclaration &); + virtual void visit(FunctionDeclaration &) { } }; -class BlockResolver: private TraversingVisitor +/** 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: - void apply(Stage &s) { s.content.visit(*this); } + ConstantSpecializer(); + + void apply(Stage &, const std::map *); + +private: + virtual void visit(VariableDeclaration &); +}; + +/** Forms links between nested blocks in the syntax tree. */ +class BlockHierarchyResolver: private TraversingVisitor +{ +private: + bool r_any_resolved; + +public: + BlockHierarchyResolver(): r_any_resolved(false) { } + + bool apply(Stage &s) { r_any_resolved = false; s.content.visit(*this); return r_any_resolved; } private: virtual void enter(Block &); - virtual void visit(InterfaceBlock &); }; +/** Resolves types of variables and base types of other types. */ +class TypeResolver: private TraversingVisitor +{ +private: + Stage *stage; + std::map alias_map; + std::map array_types; + NodeList::iterator type_insert_point; + bool r_any_resolved; + +public: + TypeResolver(); + + bool apply(Stage &); + +private: + TypeDeclaration *get_or_create_array_type(TypeDeclaration &); + void resolve_type(TypeDeclaration *&, const std::string &, bool); + virtual void visit(Block &); + virtual void visit(BasicTypeDeclaration &); + virtual void visit(ImageTypeDeclaration &); + virtual void visit(StructDeclaration &); + virtual void visit(VariableDeclaration &); + virtual void visit(FunctionDeclaration &); +}; + +/** Resolves variable references. Variable references which match the name +of an interface block are turned into interface block references. */ class VariableResolver: private TraversingVisitor { private: - Block *builtins; - std::map *members; - RefPtr iface_ref; + Stage *stage; + RefPtr r_replacement_expr; std::string block_interface; + bool r_any_resolved; bool record_target; - VariableDeclaration *assignment_target; - bool self_referencing; + bool r_self_referencing; + VariableDeclaration *r_assignment_target; public: VariableResolver(); - void apply(Stage &); + bool apply(Stage &); private: - Block *next_block(Block &); - virtual void enter(Block &); + void visit_and_replace(RefPtr &); 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 types and lvalueness of expressions. */ +class ExpressionResolver: private TraversingVisitor +{ +private: + enum Compatibility + { + NOT_COMPATIBLE, + LEFT_CONVERTIBLE, + RIGHT_CONVERTIBLE, + SAME_TYPE + }; + + Stage *stage; + std::vector basic_types; + bool r_any_resolved; + +public: + ExpressionResolver(); + + bool apply(Stage &); + +private: + static bool is_scalar(BasicTypeDeclaration &); + static bool is_vector_or_matrix(BasicTypeDeclaration &); + static BasicTypeDeclaration *get_element_type(BasicTypeDeclaration &); + static bool can_convert(BasicTypeDeclaration &, BasicTypeDeclaration &); + static Compatibility get_compatibility(BasicTypeDeclaration &, BasicTypeDeclaration &); + BasicTypeDeclaration *find_type(BasicTypeDeclaration::Kind, unsigned); + BasicTypeDeclaration *find_type(BasicTypeDeclaration &, BasicTypeDeclaration::Kind, unsigned); + void convert_to(RefPtr &, BasicTypeDeclaration &); + bool convert_to_element(RefPtr &, BasicTypeDeclaration &); + void resolve(Expression &, TypeDeclaration *, bool); + + virtual void visit(Literal &); + virtual void visit(ParenthesizedExpression &); + virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); + virtual void visit(MemberAccess &); + virtual void visit(UnaryExpression &); + void visit(BinaryExpression &, bool); + virtual void visit(BinaryExpression &); + virtual void visit(Assignment &); + virtual void visit(FunctionCall &); + virtual void visit(BasicTypeDeclaration &); + virtual void visit(VariableDeclaration &); +}; + +/** Resolves function declarations and calls. */ class FunctionResolver: private TraversingVisitor { private: - std::map > functions; + Stage *stage; + std::map > declarations; + bool r_any_resolved; public: - void apply(Stage &s) { s.content.visit(*this); } + bool 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: @@ -88,6 +197,8 @@ private: std::string out_prefix; bool function_scope; InterfaceBlock *iface_block; + bool copy_block; + Block *iface_target_block; NodeList::iterator iface_insert_point; NodeList::iterator assignment_insert_point; std::set nodes_to_remove; @@ -101,7 +212,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 &); + 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 &); @@ -110,37 +222,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