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