Enable asynchronous loading of Meshes

[libs/gl.git] / source / mesh.cpp

diff --git a/source/mesh.cpp b/source/mesh.cpp
index 150822ce85e1771a3826332cb19c12922c15a044..055345faed1f17586de0c9c93d204f4c7956e985 100644 (file)
--- a/source/mesh.cpp
+++ b/source/mesh.cpp
@@ -1,34 +1,41 @@
 #include <msp/gl/extensions/arb_vertex_array_object.h>
 #include <msp/gl/extensions/arb_vertex_shader.h>
+#include <msp/gl/extensions/nv_primitive_restart.h>
 #include "buffer.h"
 #include "error.h"
 #include "mesh.h"
 #include "renderer.h"
+#include "resourcemanager.h"
 
 using namespace std;
 
 namespace Msp {
 namespace GL {
 
-Mesh::Mesh():
-       vertices(VERTEX3),
-       vbuf(0),
-       ibuf(0),
-       vao_id(0),
-       defer_buffers(true),
-       dirty(true),
-       winding(0)
-{ }
-
-Mesh::Mesh(const VertexFormat &f):
-       vertices(f),
-       vbuf(0),
-       ibuf(0),
-       vao_id(0),
-       defer_buffers(true),
-       dirty(true),
-       winding(0)
-{ }
+Mesh::Mesh(ResourceManager *rm):
+       vertices(VERTEX3)
+{
+       init(rm);
+}
+
+Mesh::Mesh(const VertexFormat &f, ResourceManager *rm):
+       vertices(f)
+{
+       init(rm);
+}
+
+void Mesh::init(ResourceManager *rm)
+{
+       vbuf = 0;
+       ibuf = 0;
+       vao_id = 0;
+       defer_buffers = true;
+       dirty = true;
+       winding = 0;
+
+       if(rm)
+               set_manager(rm);
+}
 
 Mesh::~Mesh()
 {
@@ -136,6 +143,13 @@ void Mesh::draw() const
        if(cur && cur!=this)
                throw invalid_operation("Mesh::draw");
 
+       if(manager)
+       {
+               manager->resource_used(*this);
+               if(disallow_rendering)
+                       return;
+       }
+
        if(!current())
                vertices.apply();
        Bind bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER);
@@ -147,6 +161,13 @@ void Mesh::draw() const
 
 void Mesh::draw(Renderer &renderer) const
 {
+       if(manager)
+       {
+               manager->resource_used(*this);
+               if(disallow_rendering)
+                       return;
+       }
+
        renderer.set_mesh(this);
        renderer.set_element_buffer(ibuf);
        renderer.set_winding_test(winding);
@@ -179,6 +200,33 @@ void Mesh::unbind()
                glBindVertexArray(0);
 }
 
+Resource::AsyncLoader *Mesh::load(IO::Seekable &io)
+{
+       return new AsyncLoader(*this, io);
+}
+
+UInt64 Mesh::get_data_size() const
+{
+       UInt64 size = 0;
+       if(vbuf)
+               size += vbuf->get_size();
+       if(ibuf)
+               size += ibuf->get_size();
+       return size;
+}
+
+void Mesh::unload()
+{
+       vertices.clear();
+       vertices.use_buffer(0);
+       batches.clear();
+       delete vbuf;
+       delete ibuf;
+       defer_buffers = (vbuf || ibuf);
+       vbuf = 0;
+       ibuf = 0;
+}
+
 
 Mesh::Loader::Loader(Mesh &m):
        DataFile::ObjectLoader<Mesh>(m)
@@ -216,5 +264,65 @@ void Mesh::Loader::winding(FaceWinding w)
                obj.winding = &WindingTest::counterclockwise();
 }
 
+
+Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
+       mesh(m),
+       io(i),
+       vertex_updater(0),
+       index_updater(0),
+       phase(0)
+{
+       // Make sure the extension is initialized in the rendering thread.
+       (bool)NV_primitive_restart;
+
+       mesh.disallow_rendering = true;
+       if(mesh.defer_buffers)
+               mesh.create_buffers();
+}
+
+Mesh::AsyncLoader::~AsyncLoader()
+{
+       mesh.disallow_rendering = false;
+}
+
+bool Mesh::AsyncLoader::needs_sync() const
+{
+       return phase%2;
+}
+
+bool Mesh::AsyncLoader::process()
+{
+       if(phase==0)
+       {
+               // TODO use correct filename
+               DataFile::Parser parser(io, "async");
+               Loader loader(mesh);
+               loader.load(parser);
+       }
+       else if(phase==1)
+       {
+               vertex_updater = mesh.vertices.refresh_async();
+               if(!mesh.batches.empty())
+                       index_updater = mesh.batches.front().refresh_async();
+       }
+       else if(phase==2)
+       {
+               if(vertex_updater)
+                       vertex_updater->upload_data();
+               if(index_updater)
+                       index_updater->upload_data();
+       }
+       else if(phase==3)
+       {
+               delete vertex_updater;
+               delete index_updater;
+       }
+
+       ++phase;
+       if(phase==1 && !mesh.vbuf && !mesh.ibuf)
+               phase += 3;
+       return phase>3;
+}
+
 } // namespace GL
 } // namespace Msp