source/core/mesh.cpp

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