X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fmesh.cpp;h=45c550a0333ed4244de41b976cca39f8f4d905fa;hb=126ac7ca4053b765eab1473d2865bce728ef2428;hp=d421769abc257a775d53a4b0c73909cd92c36abb;hpb=b617c5d7b5283ad260a77f01e42e6170cabbc03d;p=libs%2Fgl.git diff --git a/source/mesh.cpp b/source/mesh.cpp index d421769a..45c550a0 100644 --- a/source/mesh.cpp +++ b/source/mesh.cpp @@ -1,12 +1,9 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - +#include +#include #include "buffer.h" +#include "error.h" #include "mesh.h" +#include "renderer.h" using namespace std; @@ -15,106 +12,206 @@ namespace GL { Mesh::Mesh(): vertices(VERTEX3), - ibuf(0) + vbuf(0), + ibuf(0), + vao_id(0), + defer_buffers(true), + dirty(false), + winding(0) { } Mesh::Mesh(const VertexFormat &f): vertices(f), - ibuf(0) + vbuf(0), + ibuf(0), + vao_id(0), + defer_buffers(true), + dirty(true), + winding(0) { } -void Mesh::use_vertex_buffer(bool b) +Mesh::~Mesh() +{ + delete vbuf; + delete ibuf; + if(vao_id) + glDeleteVertexArrays(1, &vao_id); +} + +void Mesh::clear() +{ + vertices.clear(); + batches.clear(); +} + +void Mesh::use_buffers(bool b) { + defer_buffers = false; if(b) - { - vertices.use_vertex_buffer(); - if(!ibuf) - ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); - update_index_buffer(); - } + create_buffers(); else { - vertices.use_vertex_buffer(0); + vertices.use_buffer(0); + delete vbuf; + vbuf = 0; delete ibuf; ibuf = 0; } } -float *Mesh::get_vertex(unsigned i) +void Mesh::create_buffers() { - return vertices[i]; + defer_buffers = false; + + if(!vbuf) + vbuf = new Buffer(ARRAY_BUFFER); + vertices.use_buffer(vbuf); + + if(!ibuf) + ibuf = new Buffer(ELEMENT_ARRAY_BUFFER); + + if(ARB_vertex_array_object && !vao_id) + glGenVertexArrays(1, &vao_id); } -void Mesh::add_batch(const Batch &b) +void Mesh::setup_vao() const { - batches.push_back(b); - update_index_buffer(); + 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()); + + dirty = false; } -void Mesh::clear() +unsigned Mesh::get_n_vertices() const { - vertices.clear(); - batches.clear(); + return vertices.size(); } -void Mesh::draw() const +float *Mesh::modify_vertex(unsigned i) { - vertices.apply(); - if(ibuf) - { - ibuf->bind(); - unsigned offset = 0; - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - { - i->draw_with_buffer(offset); - offset += i->size(); - } - ibuf->unbind(); - } + return vertices.modify(i); +} + +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 { - for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - i->draw(); + Batch *prev = (batches.empty() ? 0 : &batches.back()); + batches.push_back(b); + if(ibuf) + batches.back().use_buffer(ibuf, prev); } } -void Mesh::update_index_buffer() +void Mesh::set_winding(const WindingTest *w) { - if(!ibuf) - return; + winding = w; +} + +void Mesh::draw() const +{ + const Mesh *cur = current(); + if(cur && cur!=this) + throw invalid_operation("Mesh::draw"); + + if(!current()) + vertices.apply(); + Bind bind_ibuf(ibuf, ELEMENT_ARRAY_BUFFER); + Bind bind_winding(winding); - unsigned total = 0; for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) - total += i->size(); + i->draw(); +} + +void Mesh::draw(Renderer &renderer) const +{ + renderer.set_mesh(this); + renderer.set_element_buffer(ibuf); + renderer.set_winding_test(winding); - ibuf->data(total*sizeof(unsigned), 0); - unsigned offset = 0; for(list::const_iterator i=batches.begin(); i!=batches.end(); ++i) + renderer.draw(*i); +} + +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(); + else if(set_current(this)) { - ibuf->sub_data(offset*sizeof(unsigned), i->size()*sizeof(unsigned), &i->get_indices()[0]); - offset += i->size(); + glBindVertexArray(vao_id); + vertices.refresh(); + if(dirty) + setup_vao(); } - ibuf->unbind(); +} + +void Mesh::unbind() +{ + if(set_current(0)) + glBindVertexArray(0); } Mesh::Loader::Loader(Mesh &m): DataFile::ObjectLoader(m) { - add("vertices", &Loader::vertices); add("batch", &Loader::batch); + add("vertices", &Loader::vertices); + 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); + obj.dirty = true; load_sub(obj.vertices); } void Mesh::Loader::batch(PrimitiveType p) { - obj.batches.push_back(Batch(p)); - load_sub(obj.batches.back()); + Batch btc(p); + load_sub(btc); + obj.add_batch(btc); +} + +void Mesh::Loader::winding(FaceWinding w) +{ + if(w==CLOCKWISE) + obj.winding = &WindingTest::clockwise(); + else if(w==COUNTERCLOCKWISE) + obj.winding = &WindingTest::counterclockwise(); } } // namespace GL