X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fmesh.cpp;h=b5535039b44109a2f31ca8cd9c57105001966b64;hb=f5469600171c951438fb62df6427bf968adda28c;hp=67f9698cfa36468d5fb6955f49b5ce5774b95e0f;hpb=635d00bc1a9ba43ef1224681a14d0710a098cf87;p=libs%2Fgl.git diff --git a/source/mesh.cpp b/source/mesh.cpp index 67f9698c..b5535039 100644 --- a/source/mesh.cpp +++ b/source/mesh.cpp @@ -1,36 +1,45 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007-2011 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - +#include +#include +#include #include "buffer.h" -#include "extension.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), - ibuf(0), - defer_ibuf(true), - winding(0) -{ } +Mesh::Mesh(ResourceManager *rm): + vertices(VERTEX3) +{ + init(rm); +} + +Mesh::Mesh(const VertexFormat &f, ResourceManager *rm): + vertices(f) +{ + init(rm); +} -Mesh::Mesh(const VertexFormat &f): - vertices(f), - ibuf(0), - defer_ibuf(true), - winding(0) -{ } +void Mesh::init(ResourceManager *rm) +{ + vbuf = 0; + ibuf = 0; + disallow_rendering = false; + winding = 0; + + if(rm) + set_manager(rm); +} Mesh::~Mesh() { + set_manager(0); + delete vbuf; delete ibuf; } @@ -40,22 +49,20 @@ void Mesh::clear() batches.clear(); } -void Mesh::use_buffers(bool b) +void Mesh::create_buffers() { - if(b) - { - vertices.use_vertex_buffer(); - if(!ibuf) - ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); - defer_ibuf = false; - } - else - { - vertices.use_vertex_buffer(0); - delete ibuf; - ibuf = 0; - defer_ibuf = false; - } + if(vbuf && ibuf) + return; + + if(!vbuf) + vbuf = new Buffer(ARRAY_BUFFER); + vertices.use_buffer(vbuf); + + if(!ibuf) + ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); + + vtx_setup.set_vertex_array(vertices); + vtx_setup.set_index_buffer(*ibuf); } unsigned Mesh::get_n_vertices() const @@ -70,29 +77,35 @@ float *Mesh::modify_vertex(unsigned i) void Mesh::add_batch(const Batch &b) { - bool can_append = false; - if(!batches.empty()) - { - PrimitiveType type = b.get_type(); - can_append = (type==batches.back().get_type() && - type!=LINE_STRIP && type!=LINE_LOOP && type!=POLYGON && - (type!=TRIANGLE_FAN || is_supported("GL_NV_primitive_restart"))); - } - - if(defer_ibuf) - { - ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); - defer_ibuf = false; - } + create_buffers(); - if(can_append) + 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_index_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); + } } } @@ -101,29 +114,67 @@ void Mesh::set_winding(const WindingTest *w) winding = w; } -void Mesh::draw() const +void Mesh::draw(Renderer &renderer) const { - vertices.apply(); - - if(ibuf) - ibuf->bind_to(ELEMENT_ARRAY_BUFFER); - Bind bind_winding(winding); + draw(renderer, 0, 0); +} - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - i->draw(); +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(ibuf) - Buffer::unbind_from(ELEMENT_ARRAY_BUFFER); + draw(renderer, &vs, count); } -void Mesh::draw(Renderer &renderer) const +void Mesh::draw(Renderer &renderer, const VertexSetup *vs, unsigned count) const { - renderer.set_vertex_array(&vertices); - renderer.set_element_buffer(ibuf); + if(manager) + { + manager->resource_used(*this); + if(disallow_rendering) + return; + } + + renderer.set_vertex_setup(vs ? vs : &vtx_setup); renderer.set_winding_test(winding); - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - renderer.draw(*i); + if(!count) + { + for(vector::const_iterator i=batches.begin(); i!=batches.end(); ++i) + renderer.draw(*i); + } + else + { + for(vector::const_iterator i=batches.begin(); i!=batches.end(); ++i) + renderer.draw_instanced(*i, count); + } +} + +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; + vbuf = 0; + ibuf = 0; } @@ -135,9 +186,18 @@ Mesh::Loader::Loader(Mesh &m): add("winding", &Loader::winding); } -void Mesh::Loader::vertices(VertexFormat f) +void Mesh::Loader::vertices(const vector &c) { - obj.vertices.reset(f); + if(c.empty()) + throw invalid_argument("No vertex components"); + + VertexFormat fmt; + for(vector::const_iterator i=c.begin(); i!=c.end(); ++i) + fmt = (fmt, *i); + obj.vertices.reset(fmt); + if(obj.vbuf) + // Set it again to force the vertex setup to update + obj.vtx_setup.set_vertex_array(obj.vertices); load_sub(obj.vertices); } @@ -156,5 +216,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) +{ + mesh.disallow_rendering = true; + 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