-#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/khr_debug.h>
#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(ResourceManager *rm)
+Mesh::Mesh(const VertexFormat &f)
{
- init(rm);
-}
-
-Mesh::Mesh(const VertexFormat &f, ResourceManager *rm)
-{
- init(rm);
storage(f);
}
-void Mesh::init(ResourceManager *rm)
+Mesh::Mesh(Mesh &&other):
+ Resource(move(other)),
+ vertices(move(other.vertices)),
+ batches(move(other.batches)),
+ vbuf(other.vbuf),
+ ibuf(other.ibuf),
+ vtx_setup(move(other.vtx_setup)),
+ dirty(other.dirty),
+ disallow_rendering(other.disallow_rendering),
+ face_winding(other.face_winding),
+ debug_name(move(other.debug_name))
{
- vbuf = 0;
- ibuf = 0;
- dirty = 0;
- disallow_rendering = false;
- face_winding = NON_MANIFOLD;
-
- if(rm)
- set_manager(rm);
+ other.vbuf = 0;
+ other.ibuf = 0;
}
Mesh::~Mesh()
vertices.set_format(fmt);
vtx_setup.set_format(fmt);
+ if(vbuf)
+ vtx_setup.set_vertex_array(vertices);
}
void Mesh::clear()
delete vbuf;
vbuf = new Buffer;
vertices.use_buffer(vbuf);
- vtx_setup.set_vertex_array(vertices);
+ if(!vertices.get_format().empty())
+ vtx_setup.set_vertex_array(vertices);
dirty |= VERTEX_BUFFER;
#ifdef DEBUG
}
}
-unsigned Mesh::get_n_vertices() const
+size_t Mesh::get_n_vertices() const
{
return vertices.size();
}
-float *Mesh::modify_vertex(unsigned i)
+char *Mesh::modify_vertex(size_t i)
{
if(vertices.get_format().empty())
throw invalid_operation("Mesh::modify_vertex");
return vertices.modify(i);
}
-void Mesh::add_batch(const Batch &b)
+void Mesh::add_batch(Batch &&b)
{
if(batches.empty())
{
- batches.push_back(b);
+ batches.emplace_back(move(b));
if(ibuf)
batches.back().use_buffer(ibuf);
}
bool reallocate = (batches.size()==batches.capacity());
if(reallocate)
{
- for(vector<Batch>::iterator i=batches.end(); i!=batches.begin(); )
+ for(auto i=batches.end(); i!=batches.begin(); )
(--i)->use_buffer(0);
}
Batch *prev = &batches.back();
- batches.push_back(b);
+ batches.emplace_back(move(b));
if(reallocate)
{
prev = 0;
- for(vector<Batch>::iterator i=batches.begin(); i!=batches.end(); ++i)
+ for(Batch &a: batches)
{
- i->use_buffer(ibuf, prev);
- prev = &*i;
+ a.use_buffer(ibuf, prev);
+ prev = &a;
}
}
else
batches.back().set_index_type(existing_type);
else
{
- for(vector<Batch>::iterator i=batches.begin(); i!=batches.end(); ++i)
- i->set_index_type(added_type);
+ for(Batch &a: batches)
+ a.set_index_type(added_type);
}
}
if(!count)
{
- for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
- renderer.draw(*i);
+ for(const Batch &b: batches)
+ renderer.draw(b);
}
else
{
- for(vector<Batch>::const_iterator i=batches.begin(); i!=batches.end(); ++i)
- renderer.draw_instanced(*i, count);
+ for(const Batch &b: batches)
+ renderer.draw_instanced(b, count);
}
}
void Mesh::resize_buffers() const
{
if(dirty&VERTEX_BUFFER)
- vbuf->storage(vertices.get_required_buffer_size());
+ vbuf->storage(vertices.get_required_buffer_size(), STATIC);
if((dirty&INDEX_BUFFER) && !batches.empty())
- ibuf->storage(batches.front().get_required_buffer_size());
+ ibuf->storage(batches.front().get_required_buffer_size(), STATIC);
dirty = 0;
}
return new AsyncLoader(*this, io);
}
-UInt64 Mesh::get_data_size() const
+uint64_t Mesh::get_data_size() const
{
- UInt64 size = 0;
+ uint64_t size = 0;
if(vbuf)
size += vbuf->get_size();
if(ibuf)
}
-Mesh::Loader::Loader(Mesh &m, bool g):
- DataFile::ObjectLoader<Mesh>(m),
- allow_gl_calls(g)
+Mesh::Loader::Loader(Mesh &m):
+ DataFile::ObjectLoader<Mesh>(m)
{
add("batch", &Loader::batch);
add("storage", &Loader::storage);
add("winding", &Mesh::face_winding);
}
-void Mesh::Loader::storage(const vector<VertexAttribute> &a)
+void Mesh::Loader::storage(const vector<VertexAttribute> &attrs)
{
- if(a.empty())
+ if(attrs.empty())
throw invalid_argument("No vertex attributes");
VertexFormat fmt;
- for(vector<VertexAttribute>::const_iterator i=a.begin(); i!=a.end(); ++i)
- fmt = (fmt, *i);
+ for(VertexAttribute a: attrs)
+ fmt = (fmt, a);
obj.storage(fmt);
}
{
Batch btc(p);
load_sub(btc);
- obj.add_batch(btc);
+ obj.add_batch(move(btc));
}
Mesh::AsyncLoader::AsyncLoader(Mesh &m, IO::Seekable &i):
mesh(m),
- io(i),
- vertex_updater(0),
- index_updater(0),
- phase(0)
+ io(i)
{
mesh.disallow_rendering = true;
mesh.check_buffers(VERTEX_BUFFER|INDEX_BUFFER);
{
// TODO use correct filename
DataFile::Parser parser(io, "async");
- Loader loader(mesh, false);
+ Loader loader(mesh);
+ loader.allow_gl_calls = false;
loader.load(parser);
}
else if(phase==1)