source/object.cpp

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