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