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