]> git.tdb.fi Git - libs/gl.git/blob - source/core/program.h
Add generator ID for the SPIR-V compiler
[libs/gl.git] / source / core / program.h
1 #ifndef MSP_GL_PROGRAM_H_
2 #define MSP_GL_PROGRAM_H_
3
4 #include <string>
5 #include <vector>
6 #include <msp/datafile/objectloader.h>
7 #include "bindable.h"
8 #include "datatype.h"
9 #include "gl.h"
10 #include "module.h"
11 #include "tag.h"
12 #include "vertexformat.h"
13
14 namespace Msp {
15 namespace GL {
16
17 class Shader;
18
19 /**
20 A complete shader program.  Programs can be assembled of individual Shaders or
21 generated with a set of standard features.
22 */
23 class Program: public Bindable<Program>
24 {
25 public:
26         class Loader: public DataFile::CollectionObjectLoader<Program>
27         {
28         public:
29                 Loader(Program &, Collection &);
30
31         private:
32                 virtual void finish();
33
34                 void attribute(unsigned, const std::string &);
35                 void fragment_shader(const std::string &);
36                 void geometry_shader(const std::string &);
37                 void module(const std::string &);
38                 void vertex_shader(const std::string &);
39         };
40
41 private:
42         class SpecializationLoader: public DataFile::Loader
43         {
44         private:
45                 std::map<std::string, int> &spec_values;
46
47                 static ActionMap shared_actions;
48
49         public:
50                 SpecializationLoader(std::map<std::string, int> &);
51
52         private:
53                 virtual void init_actions();
54
55                 void specialize_bool(const std::string &, bool);
56                 void specialize_int(const std::string &, int);
57         };
58
59 public:
60         typedef unsigned LayoutHash;
61         struct UniformBlockInfo;
62
63         struct UniformInfo
64         {
65                 std::string name;
66                 const UniformBlockInfo *block;
67                 union
68                 {
69                         int location;
70                         unsigned offset;
71                 };
72                 unsigned array_size;
73                 unsigned array_stride;
74                 unsigned matrix_stride;
75                 DataType type;
76                 Tag tag;
77                 int binding;
78
79                 UniformInfo();
80         };
81
82         struct UniformBlockInfo
83         {
84                 std::string name;
85                 unsigned data_size;
86                 int bind_point;
87                 std::vector<const UniformInfo *> uniforms;
88                 LayoutHash layout_hash;
89
90                 UniformBlockInfo();
91         };
92
93         struct AttributeInfo
94         {
95                 std::string name;
96                 unsigned location;
97                 unsigned array_size;
98                 DataType type;
99
100                 AttributeInfo();
101         };
102
103 private:
104         struct Bindings
105         {
106                 std::map<std::string, unsigned> textures;
107                 std::map<std::string, unsigned> blocks;
108         };
109
110         unsigned id;
111         std::vector<unsigned> stage_ids;
112         const Module *module;
113         Bindings *bindings;
114         bool linked;
115         std::vector<UniformBlockInfo> uniform_blocks;
116         std::vector<UniformInfo> uniforms;
117         LayoutHash uniform_layout_hash;
118         std::vector<AttributeInfo> attributes;
119
120 public:
121         /// Constructs an empty Program with no shader stages attached.
122         Program();
123
124         /// Constructs a Program from unified source code using ProgramCompiler.
125         DEPRECATED Program(const std::string &);
126
127         /// Constructs a Program from vertex and fragment shader source code.
128         DEPRECATED Program(const std::string &, const std::string &);
129
130         /// Constructs a Program from a Module, with specialization constants.
131         Program(const Module &, const std::map<std::string, int> & = std::map<std::string, int>());
132
133 private:
134         void init();
135 public:
136         virtual ~Program();
137
138         void add_stages(const Module &, const std::map<std::string, int> & = std::map<std::string, int>());
139 private:
140         unsigned add_stage(GLenum);
141         void add_glsl_stages(const GlslModule &, const std::map<std::string, int> &);
142         void compile_glsl_stage(unsigned);
143         void add_spirv_stages(const SpirVModule &, const std::map<std::string, int> &);
144
145 public:
146         DEPRECATED void attach_shader(Shader &shader);
147         DEPRECATED void attach_shader_owned(Shader *shader);
148         DEPRECATED void detach_shader(Shader &shader);
149         DEPRECATED const std::vector<Shader *> &get_attached_shaders() const;
150
151         DEPRECATED void bind_attribute(unsigned, const std::string &);
152         DEPRECATED void bind_attribute(VertexAttribute, const std::string &);
153         DEPRECATED void bind_fragment_data(unsigned, const std::string &);
154
155         void link();
156 private:
157         void query_uniforms();
158         void query_uniform_blocks(const std::vector<UniformInfo *> &);
159         void query_attributes();
160         void collect_uniforms();
161         void collect_block_uniforms(const SpirVModule::Structure &, const std::string &, unsigned, std::vector<std::string> &);
162         void collect_attributes();
163         void update_layout_hash();
164         static LayoutHash compute_layout_hash(const std::vector<const UniformInfo *> &);
165         static bool uniform_location_compare(const UniformInfo *, const UniformInfo *);
166 public:
167         bool is_linked() const { return linked; }
168         DEPRECATED std::string get_info_log() const;
169
170         LayoutHash get_uniform_layout_hash() const { return uniform_layout_hash; }
171         const std::vector<UniformBlockInfo> &get_uniform_blocks() const { return uniform_blocks; }
172         const UniformBlockInfo &get_uniform_block_info(const std::string &) const;
173         const std::vector<UniformInfo> &get_uniforms() const { return uniforms; }
174         const UniformInfo &get_uniform_info(const std::string &) const;
175         const UniformInfo &get_uniform_info(Tag) const;
176         int get_uniform_location(const std::string &) const;
177         int get_uniform_location(Tag) const;
178         int get_uniform_binding(Tag) const;
179         const std::vector<AttributeInfo> &get_attributes() const { return attributes; }
180         const AttributeInfo &get_attribute_info(const std::string &) const;
181         int get_attribute_location(const std::string &) const;
182
183         void bind() const;
184         static void unbind();
185 };
186
187 } // namespace GL
188 } // namespace Msp
189
190 #endif