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