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