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 // Avoid synthesizing ~RefPtr in files including object.h
  29 Object::~Object()
  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 void Object::update_bounding_sphere()
  45 {
  46         vector<Vector3> points;
  47         for(vector<RefPtr<const Mesh> >::const_iterator i=meshes.begin(); i!=meshes.end(); ++i)
  48         {
  49                 const VertexArray &vertices = (*i)->get_vertices();
  50                 int offset = vertices.get_format().offset(VERTEX3);
  51                 if(offset<0)
  52                 {
  53                         // TODO Handle two-dimensional meshes
  54                         bounding_sphere = Geometry::BoundingSphere<float, 3>();
  55                         return;
  56                 }
  57
  58                 unsigned n_vertices = vertices.size();
  59                 points.reserve(points.size()+n_vertices);
  60                 for(unsigned j=0; j<n_vertices; ++j)
  61                 {
  62                         const float *v = vertices[j];
  63                         points.push_back(Vector3(v[offset], v[offset+1], v[offset+2]));
  64                 }
  65         }
  66
  67         bounding_sphere = Geometry::BoundingSphere<float, 3>::from_point_cloud(points.begin(), points.end());
  68 }
  69
  70 const Mesh *Object::get_mesh(unsigned i) const
  71 {
  72         if(i>=meshes.size())
  73                 return 0;
  74
  75         return meshes[i].get();
  76 }
  77
  78 void Object::set_technique(const Technique *t)
  79 {
  80         technique = t;
  81         technique.keep();
  82 }
  83
  84 void Object::render(const Tag &tag) const
  85 {
  86         const RenderPass *pass = get_pass(tag);
  87         if(!pass)
  88                 return;
  89
  90         Bind bind_shader(pass->get_shader_program());
  91         if(pass->get_shader_data())
  92                 pass->get_shader_data()->apply();
  93         Bind bind_material(pass->get_material());
  94         Bind bind_texturing(pass->get_texturing());
  95
  96         meshes.front()->draw();
  97 }
  98
  99 void Object::render(Renderer &renderer, const Tag &tag) const
 100 {
 101         const RenderPass *pass = get_pass(tag);
 102         if(!pass)
 103                 return;
 104
 105         Renderer::Push push(renderer);
 106         pass->apply(renderer);
 107
 108         setup_render(renderer, tag);
 109         meshes.front()->draw(renderer);
 110         finish_render(renderer, tag);
 111 }
 112
 113 void Object::render(Renderer &renderer, const ObjectInstance &inst, const Tag &tag) const
 114 {
 115         const RenderPass *pass = get_pass(tag);
 116         if(!pass)
 117                 return;
 118
 119         Renderer::Push push(renderer);
 120         pass->apply(renderer);
 121
 122         setup_render(renderer, tag);
 123         inst.setup_render(renderer, tag);
 124         unsigned lod = min<unsigned>(inst.get_level_of_detail(renderer), meshes.size()-1);
 125         meshes[lod]->draw(renderer);
 126         inst.finish_render(renderer, tag);
 127         finish_render(renderer, tag);
 128 }
 129
 130 const RenderPass *Object::get_pass(const Tag &tag) const
 131 {
 132         if(!technique)
 133                 throw logic_error("!technique");
 134         if(!technique->has_pass(tag))
 135                 return 0;
 136         return &technique->get_pass(tag);
 137 }
 138
 139
 140 Object::Loader::Loader(Object &o):
 141         DataFile::CollectionObjectLoader<Object>(o, 0)
 142 {
 143         init();
 144 }
 145
 146 Object::Loader::Loader(Object &o, Collection &c):
 147         DataFile::CollectionObjectLoader<Object>(o, &c)
 148 {
 149         init();
 150 }
 151
 152 void Object::Loader::init()
 153 {
 154         add("mesh",     &Loader::mesh_inline);
 155         add("mesh",     &Loader::mesh_inline_lod);
 156         add("mesh",     &Loader::mesh);
 157         add("mesh",     &Loader::mesh_lod);
 158         add("technique", &Loader::technique_inline);
 159         add("technique", &Loader::technique);
 160 }
 161
 162 void Object::Loader::finish()
 163 {
 164         obj.update_bounding_sphere();
 165 }
 166
 167 void Object::Loader::mesh_inline()
 168 {
 169         RefPtr<Mesh> msh = new Mesh;
 170         load_sub(*msh);
 171         obj.meshes.front() = msh;
 172 }
 173
 174 void Object::Loader::mesh_inline_lod(unsigned l)
 175 {
 176         if(l>obj.meshes.size())
 177                 throw out_of_range("Object::Loader::mesh_inline_lod");
 178
 179         RefPtr<Mesh> msh = new Mesh;
 180         load_sub(*msh);
 181         if(l==obj.meshes.size())
 182                 obj.meshes.push_back(msh);
 183         else
 184                 obj.meshes[l] = msh;
 185 }
 186
 187 void Object::Loader::mesh(const std::string &n)
 188 {
 189         obj.set_mesh(&get_collection().get<Mesh>(n));
 190 }
 191
 192 void Object::Loader::mesh_lod(unsigned l, const string &n)
 193 {
 194         obj.set_mesh(l, &get_collection().get<Mesh>(n));
 195 }
 196
 197 void Object::Loader::technique_inline()
 198 {
 199         RefPtr<Technique> tech = new Technique;
 200         if(coll)
 201                 load_sub(*tech, get_collection());
 202         else
 203                 load_sub(*tech);
 204         obj.technique = tech;
 205 }
 206
 207 void Object::Loader::technique(const std::string &n)
 208 {
 209         obj.set_technique(&get_collection().get<Technique>(n));
 210 }
 211
 212 } // namespace GL
 213 } // namespace Msp