X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fmesh.cpp;h=5f9c60d03919e2fe262d4bf848325eaee30dd6e5;hp=c9819ae91c0e60dcec38f18febe5ffeb1747f94f;hb=ca52c492bd4f2fa1a1db3a85e50eaf7c43474830;hpb=02feac06937ec4e8e122a833b4903ccf0bd6d030 diff --git a/source/mesh.cpp b/source/mesh.cpp index c9819ae9..5f9c60d0 100644 --- a/source/mesh.cpp +++ b/source/mesh.cpp @@ -1,40 +1,50 @@ #include +#include #include +#include #include "buffer.h" +#include "error.h" #include "mesh.h" #include "renderer.h" +#include "resourcemanager.h" +#include "vertexsetup.h" using namespace std; namespace Msp { namespace GL { -Mesh::Mesh(): - vertices(VERTEX3), - vbuf(0), - ibuf(0), - vao_id(0), - defer_buffers(true), - dirty(0), - winding(0) -{ } - -Mesh::Mesh(const VertexFormat &f): - vertices(f), - vbuf(0), - ibuf(0), - vao_id(0), - defer_buffers(true), - dirty(2), - 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; + vtx_setup = 0; + defer_buffers = ARB_vertex_buffer_object; + disallow_rendering = false; + winding = 0; + + if(rm) + set_manager(rm); +} Mesh::~Mesh() { + set_manager(0); + delete vtx_setup; delete vbuf; delete ibuf; - if(vao_id) - glDeleteVertexArrays(1, &vao_id); } void Mesh::clear() @@ -69,48 +79,11 @@ void Mesh::create_buffers() if(!ibuf) ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); - if(ARB_vertex_array_object && !vao_id) - glGenVertexArrays(1, &vao_id); -} - -void Mesh::refresh() const -{ - vertices.refresh(); - if(dirty) + if(ARB_vertex_array_object && !vtx_setup) { - if(dirty&1) - { - unbind(); - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - i->refresh(); - } - - if(dirty&2) - { - glBindVertexArray(vao_id); - Bind bind_vbuf(vbuf, ARRAY_BUFFER); - - const VertexFormat &fmt = vertices.get_format(); - unsigned stride = get_stride(fmt)*sizeof(float); - float *ptr = 0; - for(const unsigned char *c=fmt.begin(); c!=fmt.end(); ++c) - { - unsigned t = get_component_type(*c); - if(t>=get_component_type(ATTRIB1)) - t -= get_component_type(ATTRIB1); - unsigned sz = get_component_size(*c); - if(*c==COLOR4_UBYTE) - glVertexAttribPointer(t, 4, GL_UNSIGNED_BYTE, true, stride, ptr); - else - glVertexAttribPointer(t, sz, GL_FLOAT, false, stride, ptr); - glEnableVertexAttribArray(t); - ptr += sz; - } - glBindBuffer(ELEMENT_ARRAY_BUFFER, ibuf->get_id()); - glBindVertexArray(0); - } - - dirty = 0; + vtx_setup = new VertexSetup; + vtx_setup->set_vertex_array(vertices); + vtx_setup->set_index_buffer(*ibuf); } } @@ -129,15 +102,33 @@ 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 { + bool reallocate = (batches.size()==batches.capacity()); + if(reallocate && ibuf) + { + for(vector::iterator i=batches.end(); i!=batches.begin(); ) + (--i)->use_buffer(0); + } + Batch *prev = (batches.empty() ? 0 : &batches.back()); batches.push_back(b); if(ibuf) - batches.back().use_buffer(ibuf, prev); + { + if(reallocate) + { + prev = 0; + for(vector::iterator i=batches.begin(); i!=batches.end(); ++i) + { + i->use_buffer(ibuf, prev); + prev = &*i; + } + } + else + batches.back().use_buffer(ibuf, prev); + } } } @@ -148,58 +139,108 @@ void Mesh::set_winding(const WindingTest *w) void Mesh::draw() const { - refresh(); + const Mesh *cur = current(); + if(cur && cur!=this) + throw invalid_operation("Mesh::draw"); - if(!current()) + if(manager) { - vertices.apply(); - if(ibuf) - ibuf->bind_to(ELEMENT_ARRAY_BUFFER); + manager->resource_used(*this); + if(disallow_rendering) + return; } + if(!current()) + vertices.apply(); + BindRestore bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER); Bind bind_winding(winding); - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) + for(vector::const_iterator i=batches.begin(); i!=batches.end(); ++i) i->draw(); - - if(!current() && ibuf) - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); } void Mesh::draw(Renderer &renderer) const { - refresh(); + 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::const_iterator i=batches.begin(); i!=batches.end(); ++i) + for(vector::const_iterator i=batches.begin(); i!=batches.end(); ++i) renderer.draw(*i); } +void Mesh::draw_instanced(Renderer &renderer, const VertexSetup &vs, unsigned count) const +{ + if(vs.get_vertex_array()!=&vertices) + throw invalid_argument("Mesh::draw_instanced"); + + if(manager) + { + manager->resource_used(*this); + if(disallow_rendering) + return; + } + + renderer.set_vertex_setup(&vs); + renderer.set_winding_test(winding); + + for(vector::const_iterator i=batches.begin(); i!=batches.end(); ++i) + renderer.draw_instanced(*i, count); +} + void Mesh::bind() const { - /* If VAOs are not supported, vao_id is zero and set_current won't get + /* If VAOs are not supported, vtx_setup is zero and set_current won't get called. Thus unbind won't try to call a null function either. */ - if(!vao_id) + if(!vtx_setup) + { unbind(); - else + vertices.apply(false); + } + else if(set_current(this)) { - if(Buffer::current(ELEMENT_ARRAY_BUFFER)) - { - unbind(); - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); - } - if(set_current(this)) - glBindVertexArray(vao_id); + vtx_setup->bind(); + vertices.refresh(); } } void Mesh::unbind() { if(set_current(0)) - glBindVertexArray(0); + VertexSetup::unbind(); +} + +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; } @@ -220,7 +261,9 @@ void Mesh::Loader::vertices(const vector &c) for(vector::const_iterator i=c.begin(); i!=c.end(); ++i) fmt = (fmt, *i); obj.vertices.reset(fmt); - obj.dirty |= 2; + if(obj.vtx_setup) + // Set it again to force the vertex setup to update + obj.vtx_setup->set_vertex_array(obj.vertices); load_sub(obj.vertices); } @@ -239,5 +282,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. + (void)(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