source/materials/technique.cpp

   1 #include <msp/core/refptr.h>
   2 #include <msp/datafile/collection.h>
   3 #include <msp/fs/utils.h>
   4 #include <msp/strings/format.h>
   5 #include "material.h"
   6 #include "program.h"
   7 #include "programdata.h"
   8 #include "tag.h"
   9 #include "technique.h"
  10 #include "texture.h"
  11
  12 using namespace std;
  13
  14 namespace Msp {
  15 namespace GL {
  16
  17 RenderPass &Technique::add_pass(Tag tag)
  18 {
  19         return insert_unique(passes, tag, RenderPass())->second;
  20 }
  21
  22 bool Technique::has_pass(Tag tag) const
  23 {
  24         return passes.count(tag);
  25 }
  26
  27 const RenderPass &Technique::get_pass(Tag tag) const
  28 {
  29         return get_item(passes, tag);
  30 }
  31
  32 const RenderPass *Technique::find_pass(Tag tag) const
  33 {
  34         auto i = passes.find(tag);
  35         return (i!=passes.end() ? &i->second : 0);
  36 }
  37
  38 bool Technique::replace_texture(const string &slot, const Texture &tex)
  39 {
  40         bool replaced = false;
  41         for(auto &kvp: passes)
  42         {
  43                 Tag tag = kvp.second.get_texture_tag(slot);
  44                 if(tag.id)
  45                 {
  46                         kvp.second.set_texture(tag, &tex);
  47                         replaced = true;
  48                 }
  49         }
  50
  51         return replaced;
  52 }
  53
  54 bool Technique::replace_material(const string &slot, const Material &mat)
  55 {
  56         bool replaced = false;
  57         for(auto &kvp: passes)
  58         {
  59                 const string &pass_slot = kvp.second.get_material_slot_name();
  60                 if(!pass_slot.empty() && pass_slot==slot)
  61                 {
  62                         kvp.second.set_material(&mat);
  63                         replaced = true;
  64                 }
  65         }
  66
  67         return replaced;
  68 }
  69
  70 bool Technique::replace_uniforms(const ProgramData &shdata)
  71 {
  72         bool replaced = false;
  73         const vector<Tag> &uniform_tags = shdata.get_uniform_tags();
  74         for(auto &kvp: passes)
  75         {
  76                 RefPtr<ProgramData> new_shdata;
  77                 for(Tag t: uniform_tags)
  78                 {
  79                         Tag tag = kvp.second.get_slotted_uniform_tag(t);
  80                         if(!tag.id)
  81                                 continue;
  82
  83                         if(!new_shdata)
  84                                 new_shdata = new ProgramData(*kvp.second.get_shader_data());
  85
  86                         new_shdata->uniform(tag, shdata.get_uniform(t));
  87                         replaced = true;
  88                 }
  89
  90                 if(new_shdata)
  91                         kvp.second.set_shader_program(kvp.second.get_shader_program(), new_shdata.get());
  92         }
  93
  94         return replaced;
  95 }
  96
  97 bool Technique::has_shaders() const
  98 {
  99         for(const auto &kvp: passes)
 100                 if(kvp.second.get_shader_program())
 101                         return true;
 102         return false;
 103 }
 104
 105 void Technique::set_debug_name(const string &name)
 106 {
 107 #ifdef DEBUG
 108         for(auto &kvp: passes)
 109                 kvp.second.set_debug_name(format("%s [pass:%s]", name, kvp.first.str()));
 110 #else
 111         (void)name;
 112 #endif
 113 }
 114
 115
 116 DataFile::Loader::ActionMap Technique::Loader::shared_actions;
 117
 118 Technique::Loader::Loader(Technique &t):
 119         DataFile::CollectionObjectLoader<Technique>(t, 0)
 120 {
 121         set_actions(shared_actions);
 122 }
 123
 124 Technique::Loader::Loader(Technique &t, Collection &c):
 125         DataFile::CollectionObjectLoader<Technique>(t, &c)
 126 {
 127         set_actions(shared_actions);
 128 }
 129
 130 void Technique::Loader::init_actions()
 131 {
 132         add("inherit", &Loader::inherit);
 133         add("pass", &Loader::pass);
 134 }
 135
 136 void Technique::Loader::set_inline_base_name(const string &n)
 137 {
 138         inline_base_name = n;
 139 }
 140
 141 void Technique::Loader::inherit(const string &n)
 142 {
 143         obj.passes = get_collection().get<Technique>(n).get_passes();
 144         InheritLoader ldr(obj, get_collection());
 145         load_sub_with(ldr);
 146 }
 147
 148 void Technique::Loader::pass(const string &n)
 149 {
 150         RenderPass p;
 151         if(coll)
 152         {
 153                 RenderPass::Loader ldr(p, get_collection());
 154                 ldr.set_inline_base_name(format("%s/%s.pass", (inline_base_name.empty() ? FS::basename(get_source()) : inline_base_name), n));
 155                 load_sub_with(ldr);
 156         }
 157         else
 158                 load_sub(p);
 159
 160         if(!p.get_shader_program())
 161                 throw logic_error("no shader program in pass");
 162
 163         insert_unique(obj.passes, n, p);
 164 }
 165
 166
 167 Technique::InheritLoader::InheritLoader(Technique &t, Collection &c):
 168         DataFile::CollectionObjectLoader<Technique>(t, &c)
 169 {
 170         add("material", &InheritLoader::material);
 171         add("texture", &InheritLoader::texture);
 172         add("uniforms", &InheritLoader::uniforms);
 173 }
 174
 175 void Technique::InheritLoader::material(const string &slot, const string &name)
 176 {
 177         const Material &mat = get_collection().get<Material>(name);
 178         if(obj.replace_material(slot, mat))
 179                 return;
 180
 181         // For backwards compatibility
 182         RenderPass &pass = get_item(obj.passes, slot);
 183         if(const Material *base_mat = pass.get_material())
 184         {
 185                 for(auto &kvp: obj.passes)
 186                         if(kvp.second.get_material()==base_mat)
 187                                 kvp.second.set_material(&mat);
 188         }
 189         else
 190                 pass.set_material(&mat);
 191 }
 192
 193 void Technique::InheritLoader::texture(const string &slot, const string &name)
 194 {
 195         if(!obj.replace_texture(slot, get_collection().get<Texture>(name)))
 196                 throw key_error(slot);
 197 }
 198
 199 void Technique::InheritLoader::uniforms()
 200 {
 201         ProgramData shdata;
 202         load_sub(shdata);
 203         obj.replace_uniforms(shdata);
 204 }
 205
 206 } // namespace GL
 207 } // namespace Msp