source/core/program.cpp

   1 #include <msp/core/algorithm.h>
   2 #include "error.h"
   3 #include "program.h"
   4
   5 using namespace std;
   6
   7 namespace Msp {
   8 namespace GL {
   9
  10 Program::Program(const Module &mod, const map<string, int> &spec_values)
  11 {
  12         add_stages(mod, spec_values);
  13 }
  14
  15 void Program::add_stages(const Module &mod, const map<string, int> &spec_values)
  16 {
  17         if(has_stages())
  18                 throw invalid_operation("Program::add_stages");
  19
  20         reflect_data = ReflectData();
  21
  22         TransientData transient;
  23         switch(mod.get_format())
  24         {
  25         case Module::GLSL:
  26                 add_glsl_stages(static_cast<const GlslModule &>(mod), spec_values, transient);
  27                 break;
  28         case Module::SPIR_V:
  29                 add_spirv_stages(static_cast<const SpirVModule &>(mod), spec_values);
  30                 break;
  31         default:
  32                 throw invalid_argument("Program::add_stages");
  33         }
  34
  35         finalize(mod, transient);
  36
  37         if(mod.get_format()==Module::SPIR_V)
  38         {
  39                 collect_uniforms(static_cast<const SpirVModule &>(mod));
  40                 collect_attributes(static_cast<const SpirVModule &>(mod));
  41                 collect_builtins(static_cast<const SpirVModule &>(mod));
  42         }
  43
  44         finalize_uniforms();
  45
  46         for(const ReflectData::UniformInfo &u: reflect_data.uniforms)
  47                 require_type(u.type);
  48         for(const ReflectData::AttributeInfo &a: reflect_data.attributes)
  49                 require_type(a.type);
  50 }
  51
  52 void Program::collect_uniforms(const SpirVModule &mod)
  53 {
  54         // Prepare the default block
  55         reflect_data.uniform_blocks.push_back(ReflectData::UniformBlockInfo());
  56         vector<vector<string> > block_uniform_names(1);
  57
  58         unsigned n_descriptor_sets = 0;
  59         for(const SpirVModule::Variable &v: mod.get_variables())
  60         {
  61                 if((v.storage==SpirVModule::UNIFORM || v.storage==SpirVModule::PUSH_CONSTANT) && v.struct_type)
  62                 {
  63                         reflect_data.uniform_blocks.push_back(ReflectData::UniformBlockInfo());
  64                         ReflectData::UniformBlockInfo &info = reflect_data.uniform_blocks.back();
  65                         info.name = v.struct_type->name;
  66                         if(v.storage==SpirVModule::PUSH_CONSTANT)
  67                                 info.bind_point = ReflectData::PUSH_CONSTANT;
  68                         else
  69                         {
  70                                 if(v.binding>=0)
  71                                         info.bind_point = v.binding | (v.descriptor_set<<20);
  72                                 else
  73                                         info.bind_point = ReflectData::DEFAULT_BLOCK;
  74                                 n_descriptor_sets = max(n_descriptor_sets, v.descriptor_set+1);
  75                         }
  76                         info.data_size = v.struct_type->size;
  77
  78                         string prefix;
  79                         if(!v.name.empty())
  80                                 prefix = v.struct_type->name+".";
  81                         block_uniform_names.push_back(vector<string>());
  82                         collect_block_uniforms(*v.struct_type, prefix, 0, block_uniform_names.back());
  83                 }
  84                 else if(v.storage==SpirVModule::UNIFORM_CONSTANT && v.location>=0)
  85                 {
  86                         block_uniform_names[0].push_back(v.name);
  87                         reflect_data.uniforms.push_back(ReflectData::UniformInfo());
  88                         ReflectData::UniformInfo &info = reflect_data.uniforms.back();
  89                         info.name = v.name;
  90                         info.tag = v.name;
  91                         info.location = v.location;
  92                         if(v.binding>=0)
  93                                 info.binding = v.binding | (v.descriptor_set<<20);
  94                         n_descriptor_sets = max(n_descriptor_sets, v.descriptor_set+1);
  95                         info.array_size = max(v.array_size, 1U);
  96                         info.type = v.type;
  97                 }
  98         }
  99
 100         sort_member(reflect_data.uniforms, &ReflectData::UniformInfo::tag);
 101
 102         if(block_uniform_names.front().empty())
 103         {
 104                 reflect_data.uniform_blocks.erase(reflect_data.uniform_blocks.begin());
 105                 block_uniform_names.erase(block_uniform_names.begin());
 106         }
 107
 108         for(unsigned i=0; i<reflect_data.uniform_blocks.size(); ++i)
 109         {
 110                 ReflectData::UniformBlockInfo &block = reflect_data.uniform_blocks[i];
 111                 for(const string &n: block_uniform_names[i])
 112                 {
 113                         // The element is already known to be present
 114                         ReflectData::UniformInfo &uni = *lower_bound_member(reflect_data.uniforms, Tag(n), &ReflectData::UniformInfo::tag);
 115                         block.uniforms.push_back(&uni);
 116                         uni.block = &block;
 117                 }
 118                 block.sort_uniforms();
 119                 block.update_layout_hash();
 120         }
 121
 122         reflect_data.n_descriptor_sets = n_descriptor_sets;
 123         reflect_data.update_layout_hash();
 124 }
 125
 126 void Program::collect_block_uniforms(const SpirVModule::Structure &strct, const string &prefix, unsigned base_offset, vector<string> &uniform_names)
 127 {
 128         for(const SpirVModule::StructMember &m: strct.members)
 129         {
 130                 unsigned offset = base_offset+m.offset;
 131                 if(m.struct_type)
 132                 {
 133                         if(m.array_size)
 134                         {
 135                                 for(unsigned j=0; j<m.array_size; ++j, offset+=m.array_stride)
 136                                         collect_block_uniforms(*m.struct_type, format("%s%s[%d].", prefix, m.name, j), offset, uniform_names);
 137                         }
 138                         else
 139                                 collect_block_uniforms(*m.struct_type, prefix+m.name+".", offset, uniform_names);
 140                 }
 141                 else
 142                 {
 143                         string name = prefix+m.name;
 144                         uniform_names.push_back(name);
 145                         reflect_data.uniforms.push_back(ReflectData::UniformInfo());
 146                         ReflectData::UniformInfo &info = reflect_data.uniforms.back();
 147                         info.name = name;
 148                         info.tag = name;
 149                         info.offset = offset;
 150                         info.array_size = max(m.array_size, 1U);
 151                         info.array_stride = m.array_stride;
 152                         info.matrix_stride = m.matrix_stride;
 153                         info.type = m.type;
 154                 }
 155         }
 156 }
 157
 158 void Program::collect_attributes(const SpirVModule &mod)
 159 {
 160         for(const SpirVModule::EntryPoint &e: mod.get_entry_points())
 161                 if(e.stage==SpirVModule::VERTEX && e.name=="main")
 162                 {
 163                         for(const SpirVModule::Variable *v: e.globals)
 164                                 if(v->storage==SpirVModule::INPUT)
 165                                 {
 166                                         reflect_data.attributes.push_back(ReflectData::AttributeInfo());
 167                                         ReflectData::AttributeInfo &info = reflect_data.attributes.back();
 168                                         info.name = v->name;
 169                                         info.location = v->location;
 170                                         info.array_size = v->array_size;
 171                                         info.type = v->type;
 172                                 }
 173                 }
 174 }
 175
 176 void Program::collect_builtins(const SpirVModule &mod)
 177 {
 178         for(const SpirVModule::Variable &v: mod.get_variables())
 179                 if(v.storage==SpirVModule::OUTPUT && v.struct_type)
 180                         collect_builtins(*v.struct_type);
 181 }
 182
 183 void Program::collect_builtins(const SpirVModule::Structure &strct)
 184 {
 185         for(const SpirVModule::StructMember &m: strct.members)
 186                 if(m.builtin==SpirVModule::CLIP_DISTANCE)
 187                         reflect_data.n_clip_distances = m.array_size;
 188 }
 189
 190 const ReflectData::UniformBlockInfo &Program::get_uniform_block_info(const string &name) const
 191 {
 192         auto i = find_member(reflect_data.uniform_blocks, name, &ReflectData::UniformBlockInfo::name);
 193         if(i==reflect_data.uniform_blocks.end())
 194                 throw key_error(name);
 195         return *i;
 196 }
 197
 198 const ReflectData::UniformInfo &Program::get_uniform_info(const string &name) const
 199 {
 200         auto i = lower_bound_member(reflect_data.uniforms, Tag(name), &ReflectData::UniformInfo::tag);
 201         if(i==reflect_data.uniforms.end() || i->name!=name)
 202                 throw key_error(name);
 203         return *i;
 204 }
 205
 206 const ReflectData::UniformInfo &Program::get_uniform_info(Tag tag) const
 207 {
 208         auto i = lower_bound_member(reflect_data.uniforms, tag, &ReflectData::UniformInfo::tag);
 209         if(i==reflect_data.uniforms.end() || i->tag!=tag)
 210                 throw key_error(tag);
 211         return *i;
 212 }
 213
 214 int Program::get_uniform_location(const string &name) const
 215 {
 216         if(name[name.size()-1]==']')
 217                 throw invalid_argument("Program::get_uniform_location");
 218
 219         auto i = lower_bound_member(reflect_data.uniforms, Tag(name), &ReflectData::UniformInfo::tag);
 220         return i!=reflect_data.uniforms.end() && i->name==name && i->block->bind_point<0 ? i->location : -1;
 221 }
 222
 223 int Program::get_uniform_location(Tag tag) const
 224 {
 225         auto i = lower_bound_member(reflect_data.uniforms, tag, &ReflectData::UniformInfo::tag);
 226         return i!=reflect_data.uniforms.end() && i->tag==tag && i->block->bind_point<0 ? i->location : -1;
 227 }
 228
 229 int Program::get_uniform_binding(Tag tag) const
 230 {
 231         auto i = lower_bound_member(reflect_data.uniforms, tag, &ReflectData::UniformInfo::tag);
 232         return i!=reflect_data.uniforms.end() && i->tag==tag ? i->binding : -1;
 233 }
 234
 235 const ReflectData::AttributeInfo &Program::get_attribute_info(const string &name) const
 236 {
 237         auto i = lower_bound_member(reflect_data.attributes, name, &ReflectData::AttributeInfo::name);
 238         if(i==reflect_data.attributes.end() || i->name!=name)
 239                 throw key_error(name);
 240         return *i;
 241 }
 242
 243 int Program::get_attribute_location(const string &name) const
 244 {
 245         if(name[name.size()-1]==']')
 246                 throw invalid_argument("Program::get_attribute_location");
 247
 248         auto i = lower_bound_member(reflect_data.attributes, name, &ReflectData::AttributeInfo::name);
 249         return i!=reflect_data.attributes.end() && i->name==name ? i->location : -1;
 250 }
 251
 252
 253 Program::Loader::Loader(Program &p, Collection &c):
 254         DataFile::CollectionObjectLoader<Program>(p, &c)
 255 {
 256         add("module", &Loader::module);
 257 }
 258
 259 void Program::Loader::module(const string &n)
 260 {
 261         map<string, int> spec_values;
 262         SpecializationLoader ldr(spec_values);
 263         load_sub_with(ldr);
 264         obj.add_stages(get_collection().get<Module>(n), spec_values);
 265 }
 266
 267
 268 DataFile::Loader::ActionMap Program::SpecializationLoader::shared_actions;
 269
 270 Program::SpecializationLoader::SpecializationLoader(map<string, int> &sv):
 271         spec_values(sv)
 272 {
 273         set_actions(shared_actions);
 274 }
 275
 276 void Program::SpecializationLoader::init_actions()
 277 {
 278         add("specialize", &SpecializationLoader::specialize_bool);
 279         add("specialize", &SpecializationLoader::specialize_int);
 280 }
 281
 282 void Program::SpecializationLoader::specialize_bool(const string &name, bool value)
 283 {
 284         spec_values[name] = value;
 285 }
 286
 287 void Program::SpecializationLoader::specialize_int(const string &name, int value)
 288 {
 289         spec_values[name] = value;
 290 }
 291
 292 } // namespace GL
 293 } // namespace Msp