]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/resolve.h
Use a scratch binding to modify textures and buffers
[libs/gl.git] / source / glsl / resolve.h
1 #ifndef MSP_GL_SL_RESOLVE_H_
2 #define MSP_GL_SL_RESOLVE_H_
3
4 #include <map>
5 #include <set>
6 #include <string>
7 #include <vector>
8 #include "visitor.h"
9
10 namespace Msp {
11 namespace GL {
12 namespace SL {
13
14 /** Forms links between nested blocks in the syntax tree. */
15 class BlockHierarchyResolver: private TraversingVisitor
16 {
17 private:
18         bool r_any_resolved;
19
20 public:
21         BlockHierarchyResolver(): r_any_resolved(false) { }
22
23         bool apply(Stage &s) { r_any_resolved = false; s.content.visit(*this); return r_any_resolved; }
24
25 private:
26         virtual void enter(Block &);
27 };
28
29 /** Resolves types of variables and base types of other types. */
30 class TypeResolver: private TraversingVisitor
31 {
32 private:
33         Stage *stage;
34         std::map<TypeDeclaration *, TypeDeclaration *> alias_map;
35         std::map<TypeDeclaration *, TypeDeclaration *> array_types;
36         NodeList<Statement>::iterator type_insert_point;
37         InterfaceBlock *iface_block;
38         bool r_any_resolved;
39
40 public:
41         TypeResolver();
42
43         bool apply(Stage &);
44
45 private:
46         TypeDeclaration *get_or_create_array_type(TypeDeclaration &);
47         void resolve_type(TypeDeclaration *&, const std::string &, bool);
48         virtual void visit(Block &);
49         virtual void visit(BasicTypeDeclaration &);
50         virtual void visit(ImageTypeDeclaration &);
51         virtual void visit(StructDeclaration &);
52         virtual void visit(VariableDeclaration &);
53         virtual void visit(InterfaceBlock &);
54         virtual void visit(FunctionDeclaration &);
55 };
56
57 /** Resolves variable references.  Variable references which match the name
58 of an interface block are turned into interface block references. */
59 class VariableResolver: private TraversingVisitor
60 {
61 private:
62         Stage *stage;
63         RefPtr<Expression> r_replacement_expr;
64         bool r_any_resolved;
65         bool record_target;
66         bool r_self_referencing;
67         Assignment::Target r_assignment_target;
68         std::vector<VariableDeclaration *> redeclared_builtins;
69         std::set<Node *> nodes_to_remove;
70
71 public:
72         VariableResolver();
73
74         bool apply(Stage &);
75
76 private:
77         virtual void enter(Block &);
78         virtual void visit(RefPtr<Expression> &);
79         void check_assignment_target(Statement *);
80         virtual void visit(VariableReference &);
81         virtual void visit(InterfaceBlockReference &);
82         virtual void visit(MemberAccess &);
83         virtual void visit(Swizzle &);
84         virtual void visit(BinaryExpression &);
85         virtual void visit(Assignment &);
86         void merge_layouts(Layout &, const Layout &);
87         virtual void visit(VariableDeclaration &);
88         virtual void visit(InterfaceBlock &);
89 };
90
91 /** Resolves types and lvalueness of expressions. */
92 class ExpressionResolver: private TraversingVisitor
93 {
94 private:
95         enum Compatibility
96         {
97                 NOT_COMPATIBLE,
98                 LEFT_CONVERTIBLE,
99                 RIGHT_CONVERTIBLE,
100                 SAME_TYPE
101         };
102
103         struct ArgumentInfo
104         {
105                 BasicTypeDeclaration *type;
106                 unsigned component_count;
107
108                 ArgumentInfo(): type(0), component_count(0) { }
109         };
110
111         Stage *stage;
112         std::vector<BasicTypeDeclaration *> basic_types;
113         NodeList<Statement>::iterator insert_point;
114         bool r_any_resolved;
115
116 public:
117         ExpressionResolver();
118
119         bool apply(Stage &);
120
121 private:
122         static Compatibility get_compatibility(BasicTypeDeclaration &, BasicTypeDeclaration &);
123         BasicTypeDeclaration *find_type(BasicTypeDeclaration::Kind, unsigned, bool = true);
124         BasicTypeDeclaration *find_type(BasicTypeDeclaration &, BasicTypeDeclaration::Kind, unsigned);
125         void convert_to(RefPtr<Expression> &, BasicTypeDeclaration &);
126         bool convert_to_element(RefPtr<Expression> &, BasicTypeDeclaration &);
127         bool truncate_vector(RefPtr<Expression> &, unsigned);
128         void resolve(Expression &, TypeDeclaration *, bool);
129
130         virtual void visit(Block &);
131         virtual void visit(Literal &);
132         virtual void visit(VariableReference &);
133         virtual void visit(InterfaceBlockReference &);
134         virtual void visit(MemberAccess &);
135         virtual void visit(Swizzle &);
136         virtual void visit(UnaryExpression &);
137         void visit(BinaryExpression &, bool);
138         virtual void visit(BinaryExpression &);
139         virtual void visit(Assignment &);
140         virtual void visit(TernaryExpression &);
141         void visit_constructor(FunctionCall &);
142         virtual void visit(FunctionCall &);
143         virtual void visit(BasicTypeDeclaration &);
144         virtual void visit(VariableDeclaration &);
145 };
146
147 /** Resolves function declarations and calls. */
148 class FunctionResolver: private TraversingVisitor
149 {
150 private:
151         Stage *stage;
152         std::map<std::string, std::vector<FunctionDeclaration *> > declarations;
153         bool r_any_resolved;
154
155 public:
156         bool apply(Stage &);
157
158 private:
159         static bool can_convert_arguments(const FunctionCall &, const FunctionDeclaration &);
160
161         virtual void visit(FunctionCall &);
162         virtual void visit(FunctionDeclaration &);
163 };
164
165 } // namespace SL
166 } // namespace GL
167 } // namespace Msp
168
169 #endif