source/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 "buffer.h"
   5 #include "error.h"
   6 #include "mesh.h"
   7 #include "renderer.h"
   8 #include "resourcemanager.h"
   9 #include "vertexsetup.h"
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GL {
  15
  16 Mesh::Mesh(ResourceManager *rm):
  17         vertices(VERTEX3)
  18 {
  19         init(rm);
  20 }
  21
  22 Mesh::Mesh(const VertexFormat &f, ResourceManager *rm):
  23         vertices(f)
  24 {
  25         init(rm);
  26 }
  27
  28 void Mesh::init(ResourceManager *rm)
  29 {
  30         vbuf = 0;
  31         ibuf = 0;
  32         vtx_setup = 0;
  33         defer_buffers = ARB_vertex_buffer_object;
  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         delete vtx_setup;
  45         delete vbuf;
  46         delete ibuf;
  47 }
  48
  49 void Mesh::clear()
  50 {
  51         vertices.clear();
  52         batches.clear();
  53 }
  54
  55 void Mesh::use_buffers(bool b)
  56 {
  57         defer_buffers = false;
  58         if(b)
  59                 create_buffers();
  60         else
  61         {
  62                 vertices.use_buffer(0);
  63                 delete vbuf;
  64                 vbuf = 0;
  65                 delete ibuf;
  66                 ibuf = 0;
  67         }
  68 }
  69
  70 void Mesh::create_buffers()
  71 {
  72         defer_buffers = false;
  73
  74         if(!vbuf)
  75                 vbuf = new Buffer(ARRAY_BUFFER);
  76         vertices.use_buffer(vbuf);
  77
  78         if(!ibuf)
  79                 ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
  80
  81         if(ARB_vertex_array_object && !vtx_setup)
  82         {
  83                 vtx_setup = new VertexSetup;
  84                 vtx_setup->set_vertex_array(vertices);
  85                 vtx_setup->set_index_buffer(*ibuf);
  86         }
  87 }
  88
  89 unsigned Mesh::get_n_vertices() const
  90 {
  91         return vertices.size();
  92 }
  93
  94 float *Mesh::modify_vertex(unsigned i)
  95 {
  96         return vertices.modify(i);
  97 }
  98
  99 void Mesh::add_batch(const Batch &b)
 100 {
 101         if(defer_buffers)
 102                 create_buffers();
 103
 104         if(!batches.empty() && batches.back().can_append(b.get_type()))
 105                 batches.back().append(b);
 106         else
 107         {
 108                 bool reallocate = (batches.size()==batches.capacity());
 109                 if(reallocate && ibuf)
 110                 {
 111                         for(vector<Batch>::iterator i=batches.end(); i!=batches.begin(); )
 112                                 (--i)->use_buffer(0);
 113                 }
 114
 115                 Batch *prev = (batches.empty() ? 0 : &batches.back());
 116                 batches.push_back(b);
 117                 if(ibuf)
 118                 {
 119                         if(reallocate)
 120                         {
 121                                 prev = 0;
 122                                 for(vector<Batch>::iterator i=batches.begin(); i!=batches.end(); ++i)
 123                                 {
 124                                         i->use_buffer(ibuf, prev);
 125                                         prev = &*i;
 126                                 }
 127                         }
 128                         else
 129                                 batches.back().use_buffer(ibuf, prev);
 130                 }
 131         }
 132 }
 133
 134 void Mesh::set_winding(const WindingTest *w)
 135 {
 136         winding = w;
 137 }
 138
 139 void Mesh::draw() const
 140 {
 141         const Mesh *cur = current();
 142         if(cur && cur!=this)
 143                 throw invalid_operation("Mesh::draw");
 144
 145         if(manager)
 146         {
 147                 manager->resource_used(*this);
 148                 if(disallow_rendering)
 149                         return;
 150         }
 151
 152         if(!current())
 153                 vertices.apply();
 154         BindRestore bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER);
 155         Bind bind_winding(winding);
 156
 157         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 158                 i->draw();
 159 }
 160
 161 void Mesh::draw(Renderer &renderer) const
 162 {
 163         if(manager)
 164         {
 165                 manager->resource_used(*this);
 166                 if(disallow_rendering)
 167                         return;
 168         }
 169
 170         renderer.set_mesh(this);
 171         renderer.set_winding_test(winding);
 172
 173         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 174                 renderer.draw(*i);
 175 }
 176
 177 void Mesh::draw_instanced(Renderer &renderer, const VertexSetup &vs, unsigned count) const
 178 {
 179         if(vs.get_vertex_array()!=&vertices)
 180                 throw invalid_argument("Mesh::draw_instanced");
 181
 182         if(manager)
 183         {
 184                 manager->resource_used(*this);
 185                 if(disallow_rendering)
 186                         return;
 187         }
 188
 189         renderer.set_vertex_setup(&vs);
 190         renderer.set_winding_test(winding);
 191
 192         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 193                 renderer.draw_instanced(*i, count);
 194 }
 195
 196 void Mesh::bind() const
 197 {
 198         /* If VAOs are not supported, vtx_setup is zero and set_current won't get
 199         called.  Thus unbind won't try to call a null function either. */
 200         if(!vtx_setup)
 201         {
 202                 unbind();
 203                 vertices.apply();
 204         }
 205         else if(set_current(this))
 206         {
 207                 vtx_setup->bind();
 208                 vertices.refresh();
 209         }
 210 }
 211
 212 void Mesh::unbind()
 213 {
 214         if(set_current(0))
 215                 VertexSetup::unbind();
 216 }
 217
 218 Resource::AsyncLoader *Mesh::load(IO::Seekable &io, const Resources *)
 219 {
 220         return new AsyncLoader(*this, io);
 221 }
 222
 223 UInt64 Mesh::get_data_size() const
 224 {
 225         UInt64 size = 0;
 226         if(vbuf)
 227                 size += vbuf->get_size();
 228         if(ibuf)
 229                 size += ibuf->get_size();
 230         return size;
 231 }
 232
 233 void Mesh::unload()
 234 {
 235         vertices.clear();
 236         vertices.use_buffer(0);
 237         batches.clear();
 238         delete vbuf;
 239         delete ibuf;
 240         defer_buffers = (vbuf || ibuf);
 241         vbuf = 0;
 242         ibuf = 0;
 243 }
 244
 245
 246 Mesh::Loader::Loader(Mesh &m):
 247         DataFile::ObjectLoader<Mesh>(m)
 248 {
 249         add("batch",    &Loader::batch);
 250         add("vertices", &Loader::vertices);
 251         add("winding",  &Loader::winding);
 252 }
 253
 254 void Mesh::Loader::vertices(const vector<VertexComponent> &c)
 255 {
 256         if(c.empty())
 257                 throw invalid_argument("No vertex components");
 258
 259         VertexFormat fmt;
 260         for(vector<VertexComponent>::const_iterator i=c.begin(); i!=c.end(); ++i)
 261                 fmt = (fmt, *i);
 262         obj.vertices.reset(fmt);
 263         if(obj.vtx_setup)
 264                 // Set it again to force the vertex setup to update
 265                 obj.vtx_setup->set_vertex_array(obj.vertices);
 266         load_sub(obj.vertices);
 267 }
 268
 269 void Mesh::Loader::batch(PrimitiveType p)
 270 {
 271         Batch btc(p);
 272         load_sub(btc);
 273         obj.add_batch(btc);
 274 }
 275
 276 void Mesh::Loader::winding(FaceWinding w)
 277 {
 278         if(w==CLOCKWISE)
 279                 obj.winding = &WindingTest::clockwise();
 280         else if(w==COUNTERCLOCKWISE)
 281                 obj.winding = &WindingTest::counterclockwise();
 282 }
 283
 284
 285 Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
 286         mesh(m),
 287         io(i),
 288         vertex_updater(0),
 289         index_updater(0),
 290         phase(0)
 291 {
 292         mesh.disallow_rendering = true;
 293         if(mesh.defer_buffers)
 294                 mesh.create_buffers();
 295 }
 296
 297 Mesh::AsyncLoader::~AsyncLoader()
 298 {
 299         mesh.disallow_rendering = false;
 300         delete vertex_updater;
 301         delete index_updater;
 302 }
 303
 304 bool Mesh::AsyncLoader::needs_sync() const
 305 {
 306         return phase%2;
 307 }
 308
 309 bool Mesh::AsyncLoader::process()
 310 {
 311         if(phase==0)
 312         {
 313                 // TODO use correct filename
 314                 DataFile::Parser parser(io, "async");
 315                 Loader loader(mesh);
 316                 loader.load(parser);
 317         }
 318         else if(phase==1)
 319         {
 320                 vertex_updater = mesh.vertices.refresh_async();
 321                 if(!mesh.batches.empty())
 322                         index_updater = mesh.batches.front().refresh_async();
 323         }
 324         else if(phase==2)
 325         {
 326                 if(vertex_updater)
 327                         vertex_updater->upload_data();
 328                 if(index_updater)
 329                         index_updater->upload_data();
 330         }
 331         else if(phase==3)
 332         {
 333                 delete vertex_updater;
 334                 vertex_updater = 0;
 335                 delete index_updater;
 336                 index_updater = 0;
 337         }
 338
 339         ++phase;
 340         if(phase==1 && !mesh.vbuf && !mesh.ibuf)
 341                 phase += 3;
 342         return phase>3;
 343 }
 344
 345 } // namespace GL
 346 } // namespace Msp