source/materials/renderpass.cpp

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