X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fvertexarray.cpp;h=996871c4094ecc659566cd460175392c6b69600a;hb=c233a90fd05f1f5424d7fca94bb6b999f3061271;hp=d834ab7c7f3044d8aa691d34288bd7f1805050a6;hpb=b35ae038dd9d7456a207ecb30eb8960a00bbe71d;p=libs%2Fgl.git diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index d834ab7c..996871c4 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -1,8 +1,9 @@ -#include "arb_multitexture.h" -#include "arb_vertex_shader.h" +#include +#include #include "buffer.h" #include "error.h" #include "gl.h" +#include "mesh.h" #include "vertexarray.h" using namespace std; @@ -11,14 +12,21 @@ namespace Msp { namespace GL { VertexArray::VertexArray(const VertexFormat &f): - defer_vbuf(true), dirty(false) { reset(f); } VertexArray::~VertexArray() -{ } +{ + if(current()==this) + { + /* We must deactivate arrays here, or apply() would try to access deleted + data on the next invocation. */ + set_current(0); + apply_arrays(0, &arrays, 0, 0); + } +} void VertexArray::reset(const VertexFormat &f) { @@ -28,12 +36,18 @@ void VertexArray::reset(const VertexFormat &f) arrays.clear(); + unsigned offs = 0; for(const unsigned char *c=format.begin(); c!=format.end(); ++c) { unsigned slot = get_array_slot(*c); if(slot>=arrays.size()) arrays.resize(slot+1); - arrays[slot] = *c; + + Array &arr = arrays[slot]; + arr.component = *c; + arr.offset = offs; + + offs += get_component_size(*c); } } @@ -62,24 +76,6 @@ unsigned VertexArray::get_array_slot(unsigned char comp) } } -void VertexArray::use_vertex_buffer() -{ - if(vbuf) - return; - - vbuf = new Buffer(ARRAY_BUFFER); - defer_vbuf = false; - dirty = true; -} - -void VertexArray::use_vertex_buffer(Buffer *b) -{ - vbuf = b; - vbuf.keep(); - defer_vbuf = false; - dirty = true; -} - void VertexArray::clear() { data.clear(); @@ -93,73 +89,85 @@ void VertexArray::reserve(unsigned n) float *VertexArray::append() { data.insert(data.end(), stride, 0.0f); - set_dirty(); + dirty = true; return &*(data.end()-stride); } float *VertexArray::modify(unsigned i) { - set_dirty(); + dirty = true; return &data[0]+i*stride; } -void VertexArray::set_dirty() +unsigned VertexArray::get_data_size() const { - dirty = true; - if(defer_vbuf) - { - vbuf = new Buffer(ARRAY_BUFFER); - defer_vbuf = false; - } + return data.size()*sizeof(float); +} + +void VertexArray::upload_data() const +{ + get_buffer()->sub_data(get_offset(), get_data_size(), &data[0]); } void VertexArray::apply() const { if(format.empty()) throw invalid_operation("VertexArray::apply"); + // Don't mess up the vertex array object of a mesh + if(Mesh::current()) + throw invalid_operation("VertexArray::apply"); const VertexArray *old = current(); - if(!set_current(this)) + /* If the array has been modified, apply it even if it was the last one to + be applied. This is necessary to get the data updated to vertex buffer, and + to resync things after a format change. Radeon drivers also have some + problems with modifying vertex arrays without re-setting the pointers. */ + if(!set_current(this) && !dirty) return; + Buffer *vbuf = get_buffer(); if(vbuf) { vbuf->bind_to(ARRAY_BUFFER); if(dirty) - { - vbuf->data(data.size()*sizeof(float), &data[0]); - dirty = false; - } + update_buffer(); } - const float *base = (vbuf ? 0 : &data[0]); - unsigned offset = 0; + const float *base = (vbuf ? reinterpret_cast(get_offset()) : &data[0]); unsigned stride_bytes = stride*sizeof(float); + apply_arrays(&arrays, (old ? &old->arrays : 0), base, stride_bytes); + + if(vbuf) + Buffer::unbind_from(ARRAY_BUFFER); +} + +void VertexArray::apply_arrays(const vector *arrays, const vector *old_arrays, const float *base, unsigned stride_bytes) +{ unsigned active_tex = 0; - unsigned n_arrays = arrays.size(); - if(old) - n_arrays = max(n_arrays, old->arrays.size()); + unsigned n_arrays = arrays ? arrays->size() : 0; + if(old_arrays) + n_arrays = max(n_arrays, old_arrays->size()); for(unsigned i=0; iarrays.size() ? old->arrays[i] : 0); + const Array *arr = ((arrays && isize() && (*arrays)[i].component) ? &(*arrays)[i] : 0); + const Array *old_arr = ((old_arrays && isize() && (*old_arrays)[i].component) ? &(*old_arrays)[i] : 0); if(!arr && !old_arr) continue; - unsigned char comp = (arr ? arr : old_arr); + unsigned char comp = (arr ? arr->component : old_arr->component); unsigned sz = get_component_size(comp); unsigned t = get_component_type(comp); GLenum array_type = 0; if(t==get_component_type(VERTEX3)) { if(arr) - glVertexPointer(sz, GL_FLOAT, stride_bytes, base+offset); + glVertexPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); array_type = GL_VERTEX_ARRAY; } else if(t==get_component_type(NORMAL3)) { if(arr) - glNormalPointer(GL_FLOAT, stride_bytes, base+offset); + glNormalPointer(GL_FLOAT, stride_bytes, base+arr->offset); array_type = GL_NORMAL_ARRAY; } else if(t==get_component_type(COLOR4_FLOAT)) @@ -167,9 +175,9 @@ void VertexArray::apply() const if(arr) { if(sz==1) - glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+offset); + glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+arr->offset); else - glColorPointer(sz, GL_FLOAT, stride_bytes, base+offset); + glColorPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); } array_type = GL_COLOR_ARRAY; } @@ -182,7 +190,7 @@ void VertexArray::apply() const active_tex = t; } if(arr) - glTexCoordPointer(sz, GL_FLOAT, stride_bytes, base+offset); + glTexCoordPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); array_type = GL_TEXTURE_COORD_ARRAY; } else @@ -190,7 +198,7 @@ void VertexArray::apply() const if(t>=get_component_type(ATTRIB1)) t -= get_component_type(ATTRIB1); if(arr) - glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+offset); + glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset); } // Only change enable state if needed @@ -208,19 +216,19 @@ void VertexArray::apply() const else glDisableVertexAttribArray(t); } - - if(arr) - offset += sz; } if(active_tex) glClientActiveTexture(GL_TEXTURE0); - - if(vbuf) - Buffer::unbind_from(ARRAY_BUFFER); } +VertexArray::Array::Array(): + component(0), + offset(0) +{ } + + VertexArray::Loader::Loader(VertexArray &a): VertexArrayBuilder(a) {