Refresh lighting and culling uniforms if the camera changes in pop_state

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

diff --git a/source/mesh.cpp b/source/mesh.cpp
index 45c550a0333ed4244de41b976cca39f8f4d905fa..55d7fc0648df0920dfb93419344d6ee53fdd30a5 100644 (file)
--- a/source/mesh.cpp
+++ b/source/mesh.cpp
@@ -1,37 +1,47 @@
 #include <msp/gl/extensions/arb_vertex_array_object.h>
+#include <msp/gl/extensions/arb_vertex_buffer_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(false),
-       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 = ARB_vertex_buffer_object;
+       dirty = true;
+       disallow_rendering = false;
+       winding = 0;
+
+       if(rm)
+               set_manager(rm);
+}
 
 Mesh::~Mesh()
 {
+       set_manager(0);
        delete vbuf;
        delete ibuf;
        if(vao_id)
@@ -114,7 +124,6 @@ void Mesh::add_batch(const Batch &b)
        if(defer_buffers)
                create_buffers();
 
-       dirty |= 1;
        if(!batches.empty() && batches.back().can_append(b.get_type()))
                batches.back().append(b);
        else
@@ -137,9 +146,16 @@ 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);
+       BindRestore bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER);
        Bind bind_winding(winding);
 
        for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
@@ -148,8 +164,14 @@ 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);
 
        for(list<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
@@ -161,7 +183,10 @@ void Mesh::bind() const
        /* If VAOs are not supported, vao_id is zero and set_current won't get
        called.  Thus unbind won't try to call a null function either. */
        if(!vao_id)
+       {
                unbind();
+               vertices.apply(false);
+       }
        else if(set_current(this))
        {
                glBindVertexArray(vao_id);
@@ -177,6 +202,33 @@ void Mesh::unbind()
                glBindVertexArray(0);
 }
 
+Resource::AsyncLoader *Mesh::load(IO::Seekable &io, const Resources *)
+{
+       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)
@@ -214,5 +266,69 @@ 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;
+       delete vertex_updater;
+       delete index_updater;
+}
+
+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;
+               vertex_updater = 0;
+               delete index_updater;
+               index_updater = 0;
+       }
+
+       ++phase;
+       if(phase==1 && !mesh.vbuf && !mesh.ibuf)
+               phase += 3;
+       return phase>3;
+}
+
 } // namespace GL
 } // namespace Msp