source/object.cpp

   1 #include <msp/datafile/collection.h>
   2 #include <msp/strings/format.h>
   3 #include "material.h"
   4 #include "mesh.h"
   5 #include "object.h"
   6 #include "objectinstance.h"
   7 #include "program.h"
   8 #include "programdata.h"
   9 #include "renderer.h"
  10 #include "technique.h"
  11 #include "texturing.h"
  12
  13 using namespace std;
  14
  15 namespace Msp {
  16 namespace GL {
  17
  18 Object::Object():
  19         meshes(1)
  20 { }
  21
  22 Object::Object(const Mesh *m, const Technique *t)
  23 {
  24         set_mesh(m);
  25         set_technique(t);
  26 }
  27
  28 Object::~Object()
  29 {
  30 }
  31
  32 void Object::set_mesh(unsigned i, const Mesh *m)
  33 {
  34         if(i>meshes.size())
  35                 throw out_of_range("Object::set_mesh");
  36
  37         if(i==meshes.size())
  38                 meshes.push_back(m);
  39         else
  40                 meshes[i] = m;
  41         meshes[i].keep();
  42 }
  43
  44 const Mesh *Object::get_mesh(unsigned i) const
  45 {
  46         if(i>=meshes.size())
  47                 return 0;
  48
  49         return meshes[i].get();
  50 }
  51
  52 void Object::set_technique(const Technique *t)
  53 {
  54         technique = t;
  55         technique.keep();
  56 }
  57
  58 void Object::render(const Tag &tag) const
  59 {
  60         const RenderPass *pass = get_pass(tag);
  61         if(!pass)
  62                 return;
  63
  64         Bind bind_shader(pass->get_shader_program());
  65         if(pass->get_shader_data())
  66                 pass->get_shader_data()->apply();
  67         Bind bind_material(pass->get_material());
  68         Bind bind_texturing(pass->get_texturing());
  69
  70         meshes.front()->draw();
  71 }
  72
  73 void Object::render(Renderer &renderer, const Tag &tag) const
  74 {
  75         const RenderPass *pass = get_pass(tag);
  76         if(!pass)
  77                 return;
  78
  79         Renderer::Push push(renderer);
  80         renderer.set_shader_program(pass->get_shader_program(), pass->get_shader_data());
  81         renderer.set_material(pass->get_material());
  82         renderer.set_texturing(pass->get_texturing());
  83
  84         meshes.front()->draw(renderer);
  85 }
  86
  87 void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &tag) const
  88 {
  89         const RenderPass *pass = get_pass(tag);
  90         if(!pass)
  91                 return;
  92
  93         Renderer::Push push(renderer);
  94         renderer.set_shader_program(pass->get_shader_program(), pass->get_shader_data());
  95         renderer.set_material(pass->get_material());
  96         renderer.set_texturing(pass->get_texturing());
  97
  98         inst.setup_render(renderer, tag);
  99         unsigned lod = min<unsigned>(inst.get_level_of_detail(renderer), meshes.size()-1);
 100         meshes[lod]->draw(renderer);
 101         inst.finish_render(renderer, tag);
 102 }
 103
 104 const RenderPass *Object::get_pass(const Tag &tag) const
 105 {
 106         if(!technique || !technique->has_pass(tag))
 107                 return 0;
 108         return &technique->get_pass(tag);
 109 }
 110
 111
 112 Object::Loader::Loader(Object &o):
 113         DataFile::CollectionObjectLoader<Object>(o, 0)
 114 {
 115         init();
 116 }
 117
 118 Object::Loader::Loader(Object &o, Collection &c):
 119         DataFile::CollectionObjectLoader<Object>(o, &c)
 120 {
 121         init();
 122 }
 123
 124 void Object::Loader::init()
 125 {
 126         add("mesh",     &Loader::mesh_inline);
 127         add("mesh",     &Loader::mesh_inline_lod);
 128         add("mesh",     &Loader::mesh);
 129         add("mesh",     &Loader::mesh_lod);
 130         add("technique", &Loader::technique_inline);
 131         add("technique", &Loader::technique);
 132
 133         // Deprecated alias, will be removed
 134         add("lod_mesh", &Loader::mesh_lod);
 135 }
 136
 137 void Object::Loader::mesh_inline()
 138 {
 139         RefPtr<Mesh> msh = new Mesh;
 140         load_sub(*msh);
 141         obj.meshes.front() = msh;
 142 }
 143
 144 void Object::Loader::mesh_inline_lod(unsigned l)
 145 {
 146         if(l>obj.meshes.size())
 147                 throw out_of_range("Object::Loader::mesh_inline_lod");
 148
 149         RefPtr<Mesh> msh = new Mesh;
 150         load_sub(*msh);
 151         if(l==obj.meshes.size())
 152                 obj.meshes.push_back(msh);
 153         else
 154                 obj.meshes[l] = msh;
 155 }
 156
 157 void Object::Loader::mesh(const std::string &n)
 158 {
 159         obj.set_mesh(&get_collection().get<Mesh>(n));
 160 }
 161
 162 void Object::Loader::mesh_lod(unsigned l, const string &n)
 163 {
 164         obj.set_mesh(l, &get_collection().get<Mesh>(n));
 165 }
 166
 167 void Object::Loader::technique_inline()
 168 {
 169         RefPtr<Technique> tech = new Technique;
 170         if(coll)
 171                 load_sub(*tech, get_collection());
 172         else
 173                 load_sub(*tech);
 174         obj.technique = tech;
 175 }
 176
 177 void Object::Loader::technique(const std::string &n)
 178 {
 179         obj.set_technique(&get_collection().get<Technique>(n));
 180 }
 181
 182 } // namespace GL
 183 } // namespace Msp