source/materials/rendermethod.cpp

   1 #include <msp/core/algorithm.h>
   2 #include <msp/datafile/collection.h>
   3 #include <msp/strings/format.h>
   4 #include "error.h"
   5 #include "rendermethod.h"
   6 #include "program.h"
   7 #include "programdata.h"
   8 #include "renderer.h"
   9 #include "texture.h"
  10 #include "texture2d.h"
  11
  12 using namespace std;
  13
  14 namespace Msp {
  15 namespace GL {
  16
  17 void RenderMethod::set_material_textures()
  18 {
  19         if(!material)
  20                 return;
  21
  22         const Tag *material_texture_tags = material->get_texture_tags();
  23         for(const Tag *tag=material_texture_tags; tag->id; ++tag)
  24                 set_texture(*tag, material->get_texture(*tag), material->get_sampler(*tag));
  25 }
  26
  27 void RenderMethod::maybe_create_material_shader()
  28 {
  29         if(!material || (shprog && !shprog_from_material))
  30                 return;
  31
  32         map<string, int> extra_spec;
  33         if(receive_shadows)
  34                 extra_spec["use_shadow_map"] = true;
  35         if(image_based_lighting)
  36                 extra_spec["use_image_based_lighting"] = true;
  37
  38         shprog = material->create_compatible_shader(extra_spec);
  39
  40         if(shdata)
  41         {
  42                 RefPtr<ProgramData> old_shdata = shdata;
  43                 shdata = new ProgramData(shprog);
  44                 shdata->copy_uniforms(*old_shdata);
  45         }
  46
  47         shprog_from_material = true;
  48 }
  49
  50 void RenderMethod::set_shader_program(const Program *prog, const ProgramData *data)
  51 {
  52         shprog = prog;
  53         shprog_from_material = false;
  54         if(data)
  55         {
  56                 shdata = new ProgramData;
  57                 shdata->copy_uniforms(*data);
  58         }
  59         else
  60                 shdata = 0;
  61         maybe_create_material_shader();
  62 }
  63
  64 Tag RenderMethod::get_slotted_uniform_tag(Tag slot) const
  65 {
  66         auto i = uniform_slots.find(slot);
  67         if(i==uniform_slots.end())
  68                 return Tag();
  69         return i->second;
  70 }
  71
  72 void RenderMethod::set_material(const Material *mat)
  73 {
  74         material = mat;
  75         maybe_create_material_shader();
  76         set_material_textures();
  77 }
  78
  79 void RenderMethod::set_texture(Tag tag, const Texture *tex, const Sampler *samp)
  80 {
  81         auto i = find_member(textures, tag, &TextureSlot::tag);
  82         if(i==textures.end())
  83         {
  84                 textures.emplace_back(tag);
  85                 i = textures.end()-1;
  86         }
  87         i->texture = tex;
  88         if(samp)
  89                 i->sampler = samp;
  90 }
  91
  92 Tag RenderMethod::get_texture_tag(const string &slot) const
  93 {
  94         auto i = find_member(textures, slot, &TextureSlot::slot_name);
  95         return (i!=textures.end() ? i->tag : Tag());
  96 }
  97
  98 void RenderMethod::set_face_cull(CullMode fc)
  99 {
 100         face_cull = fc;
 101 }
 102
 103 void RenderMethod::set_blend(const Blend &b)
 104 {
 105         blend = b;
 106 }
 107
 108 void RenderMethod::set_receive_shadows(bool rs)
 109 {
 110         receive_shadows = rs;
 111         maybe_create_material_shader();
 112 }
 113
 114 void RenderMethod::set_image_based_lighting(bool ibl)
 115 {
 116         image_based_lighting = ibl;
 117         maybe_create_material_shader();
 118 }
 119
 120 void RenderMethod::apply(Renderer &renderer) const
 121 {
 122         for(const TextureSlot &t: textures)
 123                 renderer.set_texture(t.tag, t.texture, t.sampler);
 124         renderer.set_shader_program(shprog, shdata.get());
 125         if(material)
 126                 renderer.add_shader_data(material->get_shader_data());
 127         renderer.set_face_cull(face_cull);
 128         renderer.set_blend(&blend);
 129 }
 130
 131 void RenderMethod::set_debug_name(const string &name)
 132 {
 133 #ifdef DEBUG
 134         if(shdata.refcount()==1)
 135                 shdata->set_debug_name(name+" [UBO]");
 136 #else
 137         (void)name;
 138 #endif
 139 }
 140
 141
 142 DataFile::Loader::ActionMap RenderMethod::Loader::shared_actions;
 143
 144 RenderMethod::Loader::Loader(RenderMethod &p, Collection &c):
 145         DataFile::CollectionObjectLoader<RenderMethod>(p, &c)
 146 {
 147         set_actions(shared_actions);
 148 }
 149
 150 void RenderMethod::Loader::init_actions()
 151 {
 152         add("blend", &Loader::blend);
 153         add("blend", &Loader::blend_factors);
 154         add("face_cull", &RenderMethod::face_cull);
 155         add("shader",   &Loader::shader);
 156         add("image_based_lighting", &RenderMethod::image_based_lighting);
 157         add("material", &Loader::material_inline);
 158         add("material", &Loader::material);
 159         add("material_slot", &RenderMethod::material_slot);
 160         add("receive_shadows", &RenderMethod::receive_shadows);
 161         add("texture", &Loader::texture);
 162         add("uniforms", &Loader::uniforms);
 163         add("uniform_slot", &Loader::uniform_slot);
 164         add("uniform_slot", &Loader::uniform_slot2);
 165 }
 166
 167 void RenderMethod::Loader::set_inline_base_name(const string &n)
 168 {
 169         inline_base_name = n;
 170 }
 171
 172 void RenderMethod::Loader::finish()
 173 {
 174         if(obj.material)
 175                 obj.maybe_create_material_shader();
 176 }
 177
 178 void RenderMethod::Loader::blend()
 179 {
 180         load_sub(obj.blend);
 181 }
 182
 183 void RenderMethod::Loader::blend_factors(BlendFactor src, BlendFactor dest)
 184 {
 185         obj.blend = Blend(src, dest);
 186 }
 187
 188 void RenderMethod::Loader::material_inline()
 189 {
 190         Material::GenericLoader ldr(get_collection());
 191         load_sub_with(ldr);
 192         obj.material = ldr.store_object(get_collection(), inline_base_name+".mat");
 193         obj.set_material_textures();
 194 }
 195
 196 void RenderMethod::Loader::material(const string &name)
 197 {
 198         obj.material = &get_collection().get<Material>(name);
 199         obj.set_material_textures();
 200 }
 201
 202 void RenderMethod::Loader::shader(const string &n)
 203 {
 204         obj.shprog = &get_collection().get<Program>(n);
 205         obj.shprog_from_material = false;
 206         if(obj.shdata)
 207         {
 208                 RefPtr<ProgramData> old_shdata = obj.shdata;
 209                 obj.shdata = new ProgramData(obj.shprog);
 210                 obj.shdata->copy_uniforms(*old_shdata);
 211         }
 212 }
 213
 214 void RenderMethod::Loader::texture(const string &n)
 215 {
 216         auto i = find_member(obj.textures, Tag(n), &TextureSlot::tag);
 217         if(i==obj.textures.end())
 218         {
 219                 obj.textures.emplace_back(n);
 220                 i = obj.textures.end()-1;
 221         }
 222         TextureSlot::Loader ldr(*i, n, coll);
 223         load_sub_with(ldr);
 224 }
 225
 226 void RenderMethod::Loader::uniforms()
 227 {
 228         if(!obj.shprog || obj.shprog_from_material)
 229                 throw runtime_error("Shader is required for uniforms");
 230         if(!obj.shdata)
 231                 obj.shdata = new ProgramData(obj.shprog);
 232         else if(obj.shdata.refcount()>1)
 233         {
 234                 RefPtr<ProgramData> old_shdata = obj.shdata;
 235                 obj.shdata = new ProgramData;
 236                 obj.shdata->copy_uniforms(*old_shdata);
 237         }
 238         load_sub(*obj.shdata);
 239 }
 240
 241 void RenderMethod::Loader::uniform_slot(const string &name)
 242 {
 243         uniform_slot2(name, name);
 244 }
 245
 246 void RenderMethod::Loader::uniform_slot2(const string &name, const string &slot)
 247 {
 248         obj.uniform_slots[slot] = name;
 249 }
 250
 251
 252 RenderMethod::TextureSlot::Loader::Loader(TextureSlot &ts, const string &an, Collection *c):
 253         CollectionObjectLoader<TextureSlot>(ts, c),
 254         auto_slot_name(an)
 255 {
 256         add("sampler", &TextureSlot::sampler);
 257         add("slot", &Loader::slot_auto);
 258         add("slot", &TextureSlot::slot_name);
 259         add("texture", &TextureSlot::texture);
 260 }
 261
 262 void RenderMethod::TextureSlot::Loader::slot_auto()
 263 {
 264         obj.slot_name = auto_slot_name;
 265 }
 266
 267 } // namespace GL
 268 } // namespace Msp