X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.h;h=58bc4ca202e6bdbf60f5d625c1f5b5ba2004ef14;hb=3f44e477f81983c66947fe8a6d8640a3b2f9e0b3;hp=977ed156f4490ab9e282b328d59c6c88074db3f2;hpb=9ec831710f64a62ad5f2e896a55ae82a3519f29e;p=libs%2Fgl.git diff --git a/source/glsl/generate.h b/source/glsl/generate.h index 977ed156..58bc4ca2 100644 --- a/source/glsl/generate.h +++ b/source/glsl/generate.h @@ -11,23 +11,6 @@ namespace Msp { namespace GL { namespace SL { -/** Combines multiple declarations of the same identifier into one. */ -class DeclarationCombiner: private TraversingVisitor -{ -private: - std::map > functions; - std::map variables; - std::set nodes_to_remove; - -public: - void apply(Stage &); - -private: - virtual void visit(Block &); - 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. */ @@ -48,52 +31,149 @@ private: /** Forms links between nested blocks in the syntax tree. */ class BlockHierarchyResolver: private TraversingVisitor { +private: + bool r_any_resolved; + public: - void apply(Stage &s) { s.content.visit(*this); } + 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 &); }; +/** 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; + InterfaceBlock *iface_block; + 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(InterfaceBlock &); + 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: Stage *stage; - std::map *members; - RefPtr iface_ref; - std::string block_interface; + RefPtr r_replacement_expr; + bool r_any_resolved; bool record_target; - VariableDeclaration *assignment_target; - bool self_referencing; + bool r_self_referencing; + Assignment::Target r_assignment_target; + std::vector redeclared_builtins; + std::set nodes_to_remove; public: VariableResolver(); - void apply(Stage &); + bool apply(Stage &); private: virtual void enter(Block &); + virtual void visit(RefPtr &); + void check_assignment_target(Statement *); virtual void visit(VariableReference &); virtual void visit(InterfaceBlockReference &); + void add_to_chain(Assignment::Target::ChainType, unsigned); virtual void visit(MemberAccess &); + virtual void visit(Swizzle &); virtual void visit(BinaryExpression &); virtual void visit(Assignment &); - virtual void visit(StructDeclaration &); + void merge_layouts(Layout &, const Layout &); 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 + }; + + struct ArgumentInfo + { + BasicTypeDeclaration *type; + unsigned component_count; + }; + + Stage *stage; + std::vector basic_types; + NodeList::iterator insert_point; + 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 &); + bool truncate_vector(RefPtr &, unsigned); + void resolve(Expression &, TypeDeclaration *, bool); + + virtual void visit(Block &); + virtual void visit(Literal &); + virtual void visit(VariableReference &); + virtual void visit(InterfaceBlockReference &); + virtual void visit(MemberAccess &); + virtual void visit(Swizzle &); + virtual void visit(UnaryExpression &); + void visit(BinaryExpression &, bool); + virtual void visit(BinaryExpression &); + virtual void visit(Assignment &); + virtual void visit(TernaryExpression &); + void visit_constructor(FunctionCall &); + virtual void visit(FunctionCall &); + virtual void visit(BasicTypeDeclaration &); + virtual void visit(VariableDeclaration &); +}; + /** Resolves function declarations and calls. */ class FunctionResolver: private TraversingVisitor { private: Stage *stage; std::map > declarations; + bool r_any_resolved; public: - void apply(Stage &); + bool apply(Stage &); private: virtual void visit(FunctionCall &); @@ -115,8 +195,8 @@ private: std::string in_prefix; std::string out_prefix; bool function_scope; - InterfaceBlock *iface_block; bool copy_block; + std::vector declared_inputs; Block *iface_target_block; NodeList::iterator iface_insert_point; NodeList::iterator assignment_insert_point; @@ -131,8 +211,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 &); @@ -141,39 +221,6 @@ private: virtual void visit(Passthrough &); }; -/** Reorders declarations to ensure that declarations always appear before -references. */ -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