]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/finalize.h
Refactor a common part in LocationAllocator into a function
[libs/gl.git] / source / glsl / finalize.h
1 #ifndef MSP_GL_SL_FINALIZE_H_
2 #define MSP_GL_SL_FINALIZE_H_
3
4 #include <string>
5 #include "visitor.h"
6
7 namespace Msp {
8 namespace GL {
9 namespace SL {
10
11 /** Assigns offset layout qualifiers to struct members. */
12 class StructOrganizer: private TraversingVisitor
13 {
14 private:
15         int offset = -1;
16
17 public:
18         void apply(Stage &s) { s.content.visit(*this); }
19
20 private:
21         virtual void visit(StructDeclaration &);
22         virtual void visit(VariableDeclaration &);
23 };
24
25 /** Assigns location and binding layout qualifiers to interface variables and
26 blocks. */
27 class LocationAllocator: private TraversingVisitor
28 {
29 private:
30         struct Uniform
31         {
32                 int location;
33                 int desc_set;
34                 int bind_point;
35
36                 Uniform(): location(-1), desc_set(-1), bind_point(-1) { }
37         };
38
39         std::map<std::string, std::set<unsigned> > used_locations;
40         std::map<std::string, Uniform> uniforms;
41         std::map<unsigned, std::set<unsigned> > used_bindings;
42         std::vector<VariableDeclaration *> unplaced_variables;
43         std::vector<VariableDeclaration *> unbound_textures;
44         std::vector<InterfaceBlock *> unbound_blocks;
45
46 public:
47         void apply(Module &, const Features &);
48 private:
49         void apply(Stage &);
50
51         void allocate_locations(const std::string &);
52         void bind_uniform(RefPtr<Layout> &, const std::string &, unsigned);
53         void add_layout_value(RefPtr<Layout> &, const std::string &, unsigned);
54
55         bool visit_uniform(const std::string &, RefPtr<Layout> &);
56         virtual void visit(VariableDeclaration &);
57         virtual void visit(InterfaceBlock &);
58         virtual void visit(FunctionDeclaration &) { }
59 };
60
61 /** Generates default precision declarations or removes precision declarations
62 according to the requirements of the target API. */
63 class PrecisionConverter: private TraversingVisitor
64 {
65 private:
66         Stage *stage = 0;
67         std::set<std::string> have_default;
68         NodeList<Statement>::iterator insert_point;
69         std::set<Node *> nodes_to_remove;
70
71 public:
72         void apply(Stage &);
73
74 private:
75         virtual void visit(Block &);
76         virtual void visit(Precision &);
77         virtual void visit(VariableDeclaration &);
78 };
79
80 /** Base class for feature converters. */
81 class FeatureConverter: protected TraversingVisitor
82 {
83 protected:
84         Stage *stage = 0;
85         Features features;
86
87         FeatureConverter() = default;
88
89 public:
90         void apply(Stage &, const Features &);
91 protected:
92         virtual void apply() = 0;
93
94         void unsupported(const std::string &);
95
96         bool check_version(const Version &) const;
97         bool check_extension(bool Features::*) const;
98 };
99
100 /** Converts structures of the syntax tree to match a particular set of
101 features. */
102 class StructuralFeatureConverter: public FeatureConverter
103 {
104 private:
105         VariableDeclaration *frag_out = 0;
106         NodeList<Statement>::iterator uniform_insert_point;
107         std::set<Node *> nodes_to_remove;
108         RefPtr<Expression> r_replaced_reference;
109         bool r_flattened_interface = false;
110
111 public:
112         void apply(Stage &s, const Features &f) { FeatureConverter::apply(s, f); }
113 private:
114         virtual void apply();
115
116         virtual void visit(Block &);
117         virtual void visit(RefPtr<Expression> &);
118         bool supports_stage(Stage::Type) const;
119         bool supports_unified_interface_syntax() const;
120         virtual void visit(VariableReference &);
121         virtual void visit(InterfaceBlockReference &);
122         virtual void visit(MemberAccess &);
123         virtual void visit(Assignment &);
124         bool supports_unified_sampling_functions() const;
125         virtual void visit(FunctionCall &);
126         virtual void visit(VariableDeclaration &);
127         bool supports_interface_blocks(const std::string &) const;
128         virtual void visit(InterfaceBlock &);
129 };
130
131 /** Converts qualifiers on variables and blocksto match a particular set of
132 features. */
133 class QualifierConverter: private FeatureConverter
134 {
135 public:
136         void apply(Stage &s, const Features &f) { FeatureConverter::apply(s, f); }
137 private:
138         virtual void apply();
139
140         bool supports_interface_layouts() const;
141         bool supports_stage_interface_layouts() const;
142         bool supports_centroid_sampling() const;
143         bool supports_sample_sampling() const;
144         bool supports_uniform_location() const;
145         bool supports_binding() const;
146         virtual void visit(VariableDeclaration &);
147         bool supports_interface_block_location() const;
148         virtual void visit(InterfaceBlock &);
149 };
150
151 } // namespace SL
152 } // namespace GL
153 } // namespace Msp
154
155 #endif