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