source/renderpass.cpp

   1 #include <msp/datafile/collection.h>
   2 #include <msp/strings/format.h>
   3 #include "error.h"
   4 #include "material.h"
   5 #include "renderpass.h"
   6 #include "program.h"
   7 #include "programdata.h"
   8 #include "renderer.h"
   9 #include "texture.h"
  10 #include "texture2d.h"
  11 #include "texturing.h"
  12
  13 using namespace std;
  14
  15 namespace Msp {
  16 namespace GL {
  17
  18 RenderPass::RenderPass():
  19         shprog(0),
  20         shdata(0),
  21         material(0),
  22         texturing(0),
  23         back_faces(false)
  24 { }
  25
  26 RenderPass::RenderPass(const RenderPass &other):
  27         shprog(other.shprog),
  28         shdata(other.shdata),
  29         uniform_slots(other.uniform_slots),
  30         material(other.material),
  31         material_slot(other.material_slot),
  32         texturing(other.texturing ? new Texturing(*other.texturing) : 0),
  33         tex_names(other.tex_names),
  34         back_faces(other.back_faces)
  35 { }
  36
  37 RenderPass &RenderPass::operator=(const RenderPass &other)
  38 {
  39         shprog = other.shprog;
  40         shdata = other.shdata;
  41         uniform_slots = other.uniform_slots;
  42         material = other.material;
  43         material_slot = other.material_slot;
  44         texturing = other.texturing ? new Texturing(*other.texturing) : 0;
  45         tex_names = other.tex_names;
  46         back_faces = other.back_faces;
  47         return *this;
  48 }
  49
  50 RenderPass::~RenderPass()
  51 {
  52         delete texturing;
  53 }
  54
  55 void RenderPass::finalize_material()
  56 {
  57         ensure_private_shader_data();
  58
  59         if(!texturing)
  60                 texturing = new Texturing;
  61         material->attach_textures_to(*texturing, *shdata);
  62 }
  63
  64 void RenderPass::ensure_private_shader_data()
  65 {
  66         if(!shprog)
  67                 throw invalid_operation("RenderPass::ensure_private_shader_data");
  68
  69         if(!shdata)
  70                 shdata = new ProgramData(shprog);
  71         else if(shdata.refcount() > 1)
  72                 shdata = new ProgramData(*shdata);
  73 }
  74
  75 void RenderPass::set_shader_program(const Program *prog, const ProgramData *data)
  76 {
  77         shprog = prog;
  78         shdata = (data ? new ProgramData(*data) : 0);
  79 }
  80
  81 const string &RenderPass::get_slotted_uniform_name(const string &slot) const
  82 {
  83         map<string, string>::const_iterator i = uniform_slots.find(slot);
  84         if(i==uniform_slots.end())
  85         {
  86                 static string empty;
  87                 return empty;
  88         }
  89         return i->second;
  90 }
  91
  92 void RenderPass::set_material(const Material *mat)
  93 {
  94         material = mat;
  95         material.keep();
  96         finalize_material();
  97 }
  98
  99 void RenderPass::set_texture(unsigned index, const Texture *tex)
 100 {
 101         if(!texturing)
 102                 texturing = new Texturing;
 103
 104         texturing->attach(index, *tex);
 105 }
 106
 107 int RenderPass::get_texture_index(const string &n) const
 108 {
 109         map<string, unsigned>::const_iterator i = tex_names.find(n);
 110         if(i==tex_names.end())
 111                 return -1;
 112         return i->second;
 113 }
 114
 115 void RenderPass::apply(Renderer &renderer) const
 116 {
 117         renderer.set_texturing(texturing);
 118         renderer.set_material(material.get());
 119         renderer.set_shader_program(shprog, shdata.get());
 120         renderer.set_reverse_winding(back_faces);
 121 }
 122
 123
 124 RenderPass::Loader::Loader(RenderPass &p):
 125         DataFile::CollectionObjectLoader<RenderPass>(p, 0)
 126 {
 127         init();
 128 }
 129
 130 RenderPass::Loader::Loader(RenderPass &p, Collection &c):
 131         DataFile::CollectionObjectLoader<RenderPass>(p, &c)
 132 {
 133         init();
 134 }
 135
 136 void RenderPass::Loader::init()
 137 {
 138         add("shader",   &RenderPass::shprog);
 139         add("material", &Loader::material_inline);
 140         add("material", &Loader::material);
 141         add("material_slot", &RenderPass::material_slot);
 142         add("back_faces",&RenderPass::back_faces);
 143         add("texunit",  &Loader::texunit);
 144         add("texunit",  &Loader::texunit_auto);
 145         add("texunit",  &Loader::texunit_named);
 146         add("uniforms", &Loader::uniforms);
 147         add("uniform_slot", &Loader::uniform_slot);
 148 }
 149
 150 void RenderPass::Loader::material_inline()
 151 {
 152         Material::GenericLoader ldr(coll);
 153         load_sub_with(ldr);
 154         obj.material = ldr.get_material();
 155         obj.finalize_material();
 156 }
 157
 158 void RenderPass::Loader::material(const string &name)
 159 {
 160         obj.material = &get_collection().get<Material>(name);
 161         obj.material.keep();
 162         obj.finalize_material();
 163 }
 164
 165 void RenderPass::Loader::texunit(unsigned i)
 166 {
 167         if(!obj.texturing)
 168                 obj.texturing = new Texturing;
 169         TextureLoader ldr(*obj.texturing, i, coll);
 170         load_sub_with(ldr);
 171 }
 172
 173 void RenderPass::Loader::texunit_auto(const string &n)
 174 {
 175         if(!obj.texturing)
 176                 obj.texturing = new Texturing;
 177         int i = obj.texturing->find_free_unit(n);
 178         if(i<0)
 179                 throw runtime_error("no free texunit");
 180         texunit_named(i, n);
 181 }
 182
 183 void RenderPass::Loader::texunit_named(unsigned i, const string &n)
 184 {
 185         texunit(i);
 186         obj.tex_names[n] = i;
 187         obj.ensure_private_shader_data();
 188         obj.shdata->uniform(n, static_cast<int>(i));
 189 }
 190
 191 void RenderPass::Loader::uniforms()
 192 {
 193         obj.ensure_private_shader_data();
 194         load_sub(*obj.shdata);
 195 }
 196
 197 void RenderPass::Loader::uniform_slot(const string &name)
 198 {
 199         uniform_slot2(name, name);
 200 }
 201
 202 void RenderPass::Loader::uniform_slot2(const string &name, const string &slot)
 203 {
 204         obj.uniform_slots[slot] = name;
 205 }
 206
 207
 208 RenderPass::TextureLoader::TextureLoader(Texturing &t, unsigned i, Collection *c):
 209         DataFile::CollectionObjectLoader<Texturing>(t, c),
 210         index(i)
 211 {
 212         add("texture",   &TextureLoader::texture);
 213         add("texture2d", &TextureLoader::texture2d);
 214 }
 215
 216 void RenderPass::TextureLoader::finish()
 217 {
 218         if(tex)
 219         {
 220                 obj.attach(index, *tex);
 221                 tex.release();
 222         }
 223 }
 224
 225 void RenderPass::TextureLoader::texture(const string &name)
 226 {
 227         tex = &get_collection().get<Texture>(name);
 228         tex.keep();
 229 }
 230
 231 void RenderPass::TextureLoader::texture2d()
 232 {
 233         tex = new Texture2D;
 234         if(coll)
 235                 load_sub(static_cast<Texture2D &>(*tex), get_collection());
 236         else
 237                 load_sub(static_cast<Texture2D &>(*tex));
 238 }
 239
 240 } // namespace GL
 241 } // namespace Msp