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         vtx_setup.unload();
 220         delete vbuf;
 221         delete ibuf;
 222         vbuf = 0;
 223         ibuf = 0;
 224 }
 225
 226 void Mesh::set_debug_name(const string &name)
 227 {
 228 #ifdef DEBUG
 229         debug_name = name;
 230         if(vbuf)
 231                 vbuf->set_debug_name(name+" [VBO]");
 232         if(ibuf)
 233                 ibuf->set_debug_name(name+" [IBO]");
 234         vtx_setup.set_debug_name(name+" [VAO]");
 235 #else
 236         (void)name;
 237 #endif
 238 }
 239
 240
 241 Mesh::Loader::Loader(Mesh &m, bool g):
 242         DataFile::ObjectLoader<Mesh>(m),
 243         allow_gl_calls(g)
 244 {
 245         add("batch",    &Loader::batch);
 246         add("vertices", &Loader::vertices);
 247         add("winding",  &Loader::winding);
 248 }
 249
 250 void Mesh::Loader::vertices(const vector<VertexAttribute> &a)
 251 {
 252         if(a.empty())
 253                 throw invalid_argument("No vertex attributes");
 254
 255         VertexFormat fmt;
 256         for(vector<VertexAttribute>::const_iterator i=a.begin(); i!=a.end(); ++i)
 257                 fmt = (fmt, *i);
 258         obj.vertices.reset(fmt);
 259         load_sub(obj.vertices);
 260         if(allow_gl_calls)
 261         {
 262                 obj.check_buffers(VERTEX_BUFFER);
 263                 obj.vtx_setup.refresh();
 264         }
 265 }
 266
 267 void Mesh::Loader::batch(PrimitiveType p)
 268 {
 269         Batch btc(p);
 270         load_sub(btc);
 271         obj.add_batch(btc);
 272 }
 273
 274 void Mesh::Loader::winding(FaceWinding w)
 275 {
 276         if(w==CLOCKWISE)
 277                 obj.winding = &WindingTest::clockwise();
 278         else if(w==COUNTERCLOCKWISE)
 279                 obj.winding = &WindingTest::counterclockwise();
 280 }
 281
 282
 283 Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
 284         mesh(m),
 285         io(i),
 286         vertex_updater(0),
 287         index_updater(0),
 288         phase(0)
 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                 mesh.vtx_setup.refresh();
 319                 vertex_updater = mesh.vertices.refresh_async();
 320                 if(!mesh.batches.empty())
 321                         index_updater = mesh.batches.front().refresh_async();
 322         }
 323         else if(phase==2)
 324         {
 325                 if(vertex_updater)
 326                         vertex_updater->upload_data();
 327                 if(index_updater)
 328                         index_updater->upload_data();
 329         }
 330         else if(phase==3)
 331         {
 332                 delete vertex_updater;
 333                 vertex_updater = 0;
 334                 delete index_updater;
 335                 index_updater = 0;
 336         }
 337
 338         ++phase;
 339         if(phase==1 && !mesh.vbuf && !mesh.ibuf)
 340                 phase += 3;
 341         return phase>3;
 342 }
 343
 344 } // namespace GL
 345 } // namespace Msp