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         disallow_rendering = false;
  34         winding = 0;
  35
  36         if(rm)
  37                 set_manager(rm);
  38 }
  39
  40 Mesh::~Mesh()
  41 {
  42         set_manager(0);
  43         delete vtx_setup;
  44         delete vbuf;
  45         delete ibuf;
  46 }
  47
  48 void Mesh::clear()
  49 {
  50         vertices.clear();
  51         batches.clear();
  52 }
  53
  54 void Mesh::create_buffers()
  55 {
  56         if(!vbuf)
  57                 vbuf = new Buffer(ARRAY_BUFFER);
  58         vertices.use_buffer(vbuf);
  59
  60         if(!ibuf)
  61                 ibuf = new Buffer(ELEMENT_ARRAY_BUFFER);
  62
  63         if(ARB_vertex_array_object && !vtx_setup)
  64         {
  65                 vtx_setup = new VertexSetup;
  66                 vtx_setup->set_vertex_array(vertices);
  67                 vtx_setup->set_index_buffer(*ibuf);
  68         }
  69 }
  70
  71 unsigned Mesh::get_n_vertices() const
  72 {
  73         return vertices.size();
  74 }
  75
  76 float *Mesh::modify_vertex(unsigned i)
  77 {
  78         return vertices.modify(i);
  79 }
  80
  81 void Mesh::add_batch(const Batch &b)
  82 {
  83         create_buffers();
  84
  85         if(!batches.empty() && batches.back().can_append(b.get_type()))
  86                 batches.back().append(b);
  87         else
  88         {
  89                 bool reallocate = (batches.size()==batches.capacity());
  90                 if(reallocate && ibuf)
  91                 {
  92                         for(vector<Batch>::iterator i=batches.end(); i!=batches.begin(); )
  93                                 (--i)->use_buffer(0);
  94                 }
  95
  96                 Batch *prev = (batches.empty() ? 0 : &batches.back());
  97                 batches.push_back(b);
  98                 if(ibuf)
  99                 {
 100                         if(reallocate)
 101                         {
 102                                 prev = 0;
 103                                 for(vector<Batch>::iterator i=batches.begin(); i!=batches.end(); ++i)
 104                                 {
 105                                         i->use_buffer(ibuf, prev);
 106                                         prev = &*i;
 107                                 }
 108                         }
 109                         else
 110                                 batches.back().use_buffer(ibuf, prev);
 111                 }
 112         }
 113 }
 114
 115 void Mesh::set_winding(const WindingTest *w)
 116 {
 117         winding = w;
 118 }
 119
 120 void Mesh::draw() const
 121 {
 122         const Mesh *cur = current();
 123         if(cur && cur!=this)
 124                 throw invalid_operation("Mesh::draw");
 125
 126         if(manager)
 127         {
 128                 manager->resource_used(*this);
 129                 if(disallow_rendering)
 130                         return;
 131         }
 132
 133         if(!current())
 134                 vertices.apply();
 135         BindRestore bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER);
 136         Bind bind_winding(winding);
 137
 138         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 139                 i->draw();
 140 }
 141
 142 void Mesh::draw(Renderer &renderer) const
 143 {
 144         if(manager)
 145         {
 146                 manager->resource_used(*this);
 147                 if(disallow_rendering)
 148                         return;
 149         }
 150
 151         renderer.set_mesh(this);
 152         renderer.set_winding_test(winding);
 153
 154         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 155                 renderer.draw(*i);
 156 }
 157
 158 void Mesh::draw_instanced(Renderer &renderer, const VertexSetup &vs, unsigned count) const
 159 {
 160         if(vs.get_vertex_array()!=&vertices)
 161                 throw invalid_argument("Mesh::draw_instanced");
 162
 163         if(manager)
 164         {
 165                 manager->resource_used(*this);
 166                 if(disallow_rendering)
 167                         return;
 168         }
 169
 170         renderer.set_vertex_setup(&vs);
 171         renderer.set_winding_test(winding);
 172
 173         for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
 174                 renderer.draw_instanced(*i, count);
 175 }
 176
 177 void Mesh::bind() const
 178 {
 179         /* If VAOs are not supported, vtx_setup is zero and set_current won't get
 180         called.  Thus unbind won't try to call a null function either. */
 181         if(!vtx_setup)
 182         {
 183                 unbind();
 184                 vertices.apply();
 185         }
 186         else if(set_current(this))
 187         {
 188                 vtx_setup->bind();
 189                 vertices.refresh();
 190         }
 191 }
 192
 193 void Mesh::unbind()
 194 {
 195         if(set_current(0))
 196                 VertexSetup::unbind();
 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
 226 Mesh::Loader::Loader(Mesh &m):
 227         DataFile::ObjectLoader<Mesh>(m)
 228 {
 229         add("batch",    &Loader::batch);
 230         add("vertices", &Loader::vertices);
 231         add("winding",  &Loader::winding);
 232 }
 233
 234 void Mesh::Loader::vertices(const vector<VertexComponent> &c)
 235 {
 236         if(c.empty())
 237                 throw invalid_argument("No vertex components");
 238
 239         VertexFormat fmt;
 240         for(vector<VertexComponent>::const_iterator i=c.begin(); i!=c.end(); ++i)
 241                 fmt = (fmt, *i);
 242         obj.vertices.reset(fmt);
 243         if(obj.vtx_setup)
 244                 // Set it again to force the vertex setup to update
 245                 obj.vtx_setup->set_vertex_array(obj.vertices);
 246         load_sub(obj.vertices);
 247 }
 248
 249 void Mesh::Loader::batch(PrimitiveType p)
 250 {
 251         Batch btc(p);
 252         load_sub(btc);
 253         obj.add_batch(btc);
 254 }
 255
 256 void Mesh::Loader::winding(FaceWinding w)
 257 {
 258         if(w==CLOCKWISE)
 259                 obj.winding = &WindingTest::clockwise();
 260         else if(w==COUNTERCLOCKWISE)
 261                 obj.winding = &WindingTest::counterclockwise();
 262 }
 263
 264
 265 Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
 266         mesh(m),
 267         io(i),
 268         vertex_updater(0),
 269         index_updater(0),
 270         phase(0)
 271 {
 272         mesh.disallow_rendering = true;
 273         mesh.create_buffers();
 274 }
 275
 276 Mesh::AsyncLoader::~AsyncLoader()
 277 {
 278         mesh.disallow_rendering = false;
 279         delete vertex_updater;
 280         delete index_updater;
 281 }
 282
 283 bool Mesh::AsyncLoader::needs_sync() const
 284 {
 285         return phase%2;
 286 }
 287
 288 bool Mesh::AsyncLoader::process()
 289 {
 290         if(phase==0)
 291         {
 292                 // TODO use correct filename
 293                 DataFile::Parser parser(io, "async");
 294                 Loader loader(mesh);
 295                 loader.load(parser);
 296         }
 297         else if(phase==1)
 298         {
 299                 vertex_updater = mesh.vertices.refresh_async();
 300                 if(!mesh.batches.empty())
 301                         index_updater = mesh.batches.front().refresh_async();
 302         }
 303         else if(phase==2)
 304         {
 305                 if(vertex_updater)
 306                         vertex_updater->upload_data();
 307                 if(index_updater)
 308                         index_updater->upload_data();
 309         }
 310         else if(phase==3)
 311         {
 312                 delete vertex_updater;
 313                 vertex_updater = 0;
 314                 delete index_updater;
 315                 index_updater = 0;
 316         }
 317
 318         ++phase;
 319         if(phase==1 && !mesh.vbuf && !mesh.ibuf)
 320                 phase += 3;
 321         return phase>3;
 322 }
 323
 324 } // namespace GL
 325 } // namespace Msp