source/core/mesh.cpp

   1 #include "buffer.h"
   2 #include "error.h"
   3 #include "mesh.h"
   4 #include "renderer.h"
   5 #include "resourcemanager.h"
   6
   7 using namespace std;
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 Mesh::Mesh():
  13         vbuf(0),
  14         ibuf(0),
  15         dirty(0),
  16         disallow_rendering(false),
  17         face_winding(NON_MANIFOLD)
  18 { }
  19
  20 Mesh::Mesh(const VertexFormat &f):
  21         Mesh()
  22 {
  23         storage(f);
  24 }
  25
  26 Mesh::~Mesh()
  27 {
  28         set_manager(0);
  29         batches.clear();
  30         delete vbuf;
  31         delete ibuf;
  32 }
  33
  34 void Mesh::storage(const VertexFormat &fmt)
  35 {
  36         if(!vertices.get_format().empty())
  37                 throw invalid_operation("Mesh::storage");
  38
  39         vertices.set_format(fmt);
  40         vtx_setup.set_format(fmt);
  41 }
  42
  43 void Mesh::clear()
  44 {
  45         vertices.clear();
  46         batches.clear();
  47 }
  48
  49 void Mesh::check_buffers(unsigned mask)
  50 {
  51         if(mask&VERTEX_BUFFER)
  52         {
  53                 unsigned req_size = vertices.get_required_buffer_size();
  54                 if(!vbuf || (vbuf->get_size()>0 && vbuf->get_size()<req_size))
  55                 {
  56                         delete vbuf;
  57                         vbuf = new Buffer;
  58                         vertices.use_buffer(vbuf);
  59                         vtx_setup.set_vertex_array(vertices);
  60                         dirty |= VERTEX_BUFFER;
  61
  62 #ifdef DEBUG
  63                         if(!debug_name.empty())
  64                                 vbuf->set_debug_name(debug_name+" [VBO]");
  65 #endif
  66                 }
  67         }
  68
  69         if(mask&INDEX_BUFFER)
  70         {
  71                 unsigned req_size = (batches.empty() ? 0 : batches.front().get_required_buffer_size());
  72                 if(!ibuf || (ibuf->get_size()>0 && ibuf->get_size()<req_size))
  73                 {
  74                         delete ibuf;
  75                         ibuf = new Buffer;
  76                         if(!batches.empty())
  77                                 batches.front().change_buffer(ibuf);
  78                         dirty |= INDEX_BUFFER;
  79
  80 #ifdef DEBUG
  81                         if(!debug_name.empty())
  82                                 vbuf->set_debug_name(debug_name+" [IBO]");
  83 #endif
  84                 }
  85
  86                 if(!batches.empty())
  87                         vtx_setup.set_index_buffer(*ibuf, batches.front().get_index_type());
  88         }
  89 }
  90
  91 unsigned Mesh::get_n_vertices() const
  92 {
  93         return vertices.size();
  94 }
  95
  96 char *Mesh::modify_vertex(unsigned i)
  97 {
  98         if(vertices.get_format().empty())
  99                 throw invalid_operation("Mesh::modify_vertex");
 100         return vertices.modify(i);
 101 }
 102
 103 void Mesh::add_batch(const Batch &b)
 104 {
 105         if(batches.empty())
 106         {
 107                 batches.push_back(b);
 108                 if(ibuf)
 109                         batches.back().use_buffer(ibuf);
 110         }
 111         else if(batches.back().can_append(b.get_type()))
 112                 batches.back().append(b);
 113         else
 114         {
 115                 bool reallocate = (batches.size()==batches.capacity());
 116                 if(reallocate)
 117                 {
 118                         for(auto i=batches.end(); i!=batches.begin(); )
 119                                 (--i)->use_buffer(0);
 120                 }
 121
 122                 Batch *prev = &batches.back();
 123                 batches.push_back(b);
 124                 if(reallocate)
 125                 {
 126                         prev = 0;
 127                         for(Batch &a: batches)
 128                         {
 129                                 a.use_buffer(ibuf, prev);
 130                                 prev = &a;
 131                         }
 132                 }
 133                 else
 134                         batches.back().use_buffer(ibuf, prev);
 135         }
 136
 137         DataType existing_type = batches.front().get_index_type();
 138         DataType added_type = batches.back().get_index_type();
 139         if(existing_type!=added_type)
 140         {
 141                 if(get_type_size(existing_type)>get_type_size(added_type))
 142                         batches.back().set_index_type(existing_type);
 143                 else
 144                 {
 145                         for(Batch &a: batches)
 146                                 a.set_index_type(added_type);
 147                 }
 148         }
 149
 150         check_buffers(INDEX_BUFFER);
 151 }
 152
 153 void Mesh::set_winding(FaceWinding w)
 154 {
 155         face_winding = w;
 156 }
 157
 158 void Mesh::draw(Renderer &renderer) const
 159 {
 160         draw(renderer, 0, 0);
 161 }
 162
 163 void Mesh::draw_instanced(Renderer &renderer, const VertexSetup &vs, unsigned count) const
 164 {
 165         if(vs.get_vertex_array()!=&vertices)
 166                 throw invalid_argument("Mesh::draw_instanced");
 167
 168         draw(renderer, &vs, count);
 169 }
 170
 171 void Mesh::draw(Renderer &renderer, const VertexSetup *vs, unsigned count) const
 172 {
 173         if(manager)
 174         {
 175                 manager->resource_used(*this);
 176                 if(disallow_rendering)
 177                         return;
 178         }
 179
 180         if(batches.empty())
 181                 return;
 182
 183         if(dirty)
 184                 resize_buffers();
 185
 186         renderer.set_vertex_setup(vs ? vs : &vtx_setup);
 187         renderer.set_front_face(face_winding);
 188
 189         if(!count)
 190         {
 191                 for(const Batch &b: batches)
 192                         renderer.draw(b);
 193         }
 194         else
 195         {
 196                 for(const Batch &b: batches)
 197                         renderer.draw_instanced(b, count);
 198         }
 199 }
 200
 201 void Mesh::resize_buffers() const
 202 {
 203         if(dirty&VERTEX_BUFFER)
 204                 vbuf->storage(vertices.get_required_buffer_size());
 205         if((dirty&INDEX_BUFFER) && !batches.empty())
 206                 ibuf->storage(batches.front().get_required_buffer_size());
 207         dirty = 0;
 208 }
 209
 210 Resource::AsyncLoader *Mesh::load(IO::Seekable &io, const Resources *)
 211 {
 212         return new AsyncLoader(*this, io);
 213 }
 214
 215 uint64_t Mesh::get_data_size() const
 216 {
 217         uint64_t size = 0;
 218         if(vbuf)
 219                 size += vbuf->get_size();
 220         if(ibuf)
 221                 size += ibuf->get_size();
 222         return size;
 223 }
 224
 225 void Mesh::unload()
 226 {
 227         vertices.clear();
 228         vertices.use_buffer(0);
 229         batches.clear();
 230         vtx_setup.unload();
 231         delete vbuf;
 232         delete ibuf;
 233         vbuf = 0;
 234         ibuf = 0;
 235 }
 236
 237 void Mesh::set_debug_name(const string &name)
 238 {
 239 #ifdef DEBUG
 240         debug_name = name;
 241         if(vbuf)
 242                 vbuf->set_debug_name(name+" [VBO]");
 243         if(ibuf)
 244                 ibuf->set_debug_name(name+" [IBO]");
 245         vtx_setup.set_debug_name(name+" [VAO]");
 246 #else
 247         (void)name;
 248 #endif
 249 }
 250
 251
 252 Mesh::Loader::Loader(Mesh &m, bool g):
 253         DataFile::ObjectLoader<Mesh>(m),
 254         allow_gl_calls(g)
 255 {
 256         add("batch",    &Loader::batch);
 257         add("storage",  &Loader::storage);
 258         add("vertices", &Loader::vertices);
 259         add("vertices", &Loader::vertices_with_format);
 260         add("winding",  &Mesh::face_winding);
 261 }
 262
 263 void Mesh::Loader::storage(const vector<VertexAttribute> &attrs)
 264 {
 265         if(attrs.empty())
 266                 throw invalid_argument("No vertex attributes");
 267
 268         VertexFormat fmt;
 269         for(VertexAttribute a: attrs)
 270                 fmt = (fmt, a);
 271         obj.storage(fmt);
 272 }
 273
 274 void Mesh::Loader::vertices()
 275 {
 276         load_sub(obj.vertices);
 277         if(allow_gl_calls)
 278                 obj.check_buffers(VERTEX_BUFFER);
 279 }
 280
 281 void Mesh::Loader::vertices_with_format(const vector<VertexAttribute> &a)
 282 {
 283         storage(a);
 284         vertices();
 285 }
 286
 287 void Mesh::Loader::batch(PrimitiveType p)
 288 {
 289         Batch btc(p);
 290         load_sub(btc);
 291         obj.add_batch(btc);
 292 }
 293
 294
 295 Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
 296         mesh(m),
 297         io(i),
 298         vertex_updater(0),
 299         index_updater(0),
 300         phase(0)
 301 {
 302         mesh.disallow_rendering = true;
 303         mesh.check_buffers(VERTEX_BUFFER|INDEX_BUFFER);
 304 }
 305
 306 Mesh::AsyncLoader::~AsyncLoader()
 307 {
 308         mesh.disallow_rendering = false;
 309         delete vertex_updater;
 310         delete index_updater;
 311 }
 312
 313 bool Mesh::AsyncLoader::needs_sync() const
 314 {
 315         return phase%2;
 316 }
 317
 318 bool Mesh::AsyncLoader::process()
 319 {
 320         if(phase==0)
 321         {
 322                 // TODO use correct filename
 323                 DataFile::Parser parser(io, "async");
 324                 Loader loader(mesh, false);
 325                 loader.load(parser);
 326         }
 327         else if(phase==1)
 328         {
 329                 mesh.resize_buffers();
 330                 vertex_updater = mesh.vertices.refresh_async();
 331                 if(!mesh.batches.empty())
 332                         index_updater = mesh.batches.front().refresh_async();
 333         }
 334         else if(phase==2)
 335         {
 336                 if(vertex_updater)
 337                         vertex_updater->upload_data();
 338                 if(index_updater)
 339                         index_updater->upload_data();
 340         }
 341         else if(phase==3)
 342         {
 343                 delete vertex_updater;
 344                 vertex_updater = 0;
 345                 delete index_updater;
 346                 index_updater = 0;
 347         }
 348
 349         ++phase;
 350         if(phase==1 && !mesh.vbuf && !mesh.ibuf)
 351                 phase += 3;
 352         return phase>3;
 353 }
 354
 355 } // namespace GL
 356 } // namespace Msp