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