X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fvertexarray.cpp;h=9947ac1108a59ef5b5a9a72d9caaa7987ba11782;hb=a40fc85277dba5c34402a0e703d038efd30cc57b;hp=6c0e5f1aea363c8de02eeaea1c714f7ac1196645;hpb=ab59f5a9e66b3fc7872ad96ec7949940189f0819;p=libs%2Fgl.git diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index 6c0e5f1a..9947ac11 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; @@ -10,15 +11,18 @@ using namespace std; namespace Msp { namespace GL { -VertexArray::VertexArray(const VertexFormat &f): - defer_vbuf(true), - dirty(false) +VertexArray::VertexArray(const VertexFormat &f) { reset(f); } VertexArray::~VertexArray() -{ } +{ + /* Unbind accesses the current VertexArray, so a call from ~Bindable would + try to access destroyed data. */ + if(current()==this) + unbind(); +} void VertexArray::reset(const VertexFormat &f) { @@ -28,7 +32,7 @@ void VertexArray::reset(const VertexFormat &f) arrays.clear(); - unsigned offset = 0; + unsigned offs = 0; for(const unsigned char *c=format.begin(); c!=format.end(); ++c) { unsigned slot = get_array_slot(*c); @@ -37,9 +41,9 @@ void VertexArray::reset(const VertexFormat &f) Array &arr = arrays[slot]; arr.component = *c; - arr.offset = offset; + arr.offset = offs; - offset += get_component_size(*c); + offs += get_component_size(*c); } } @@ -68,24 +72,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(); @@ -99,127 +85,89 @@ void VertexArray::reserve(unsigned n) float *VertexArray::append() { data.insert(data.end(), stride, 0.0f); - set_dirty(); + update_offset(); + 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::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"); + + static Require _req(ARB_vertex_shader); 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; - if(vbuf) - { - vbuf->bind_to(ARRAY_BUFFER); - if(dirty) - { - vbuf->data(data.size()*sizeof(float), &data[0]); - dirty = false; - } - } + const Buffer *vbuf = get_buffer(); + Bind _bind_vbuf(vbuf, ARRAY_BUFFER); + if(vbuf && dirty) + update_buffer(); - const float *base = (vbuf ? 0 : &data[0]); + const float *base = (vbuf ? reinterpret_cast(get_offset()) : &data[0]); unsigned stride_bytes = stride*sizeof(float); - unsigned active_tex = 0; - unsigned n_arrays = arrays.size(); - if(old) - n_arrays = max(n_arrays, old->arrays.size()); + apply_arrays(&arrays, (old ? &old->arrays : 0), base, stride_bytes); +} + +void VertexArray::apply_arrays(const vector *arrays, const vector *old_arrays, const float *base, unsigned stride_bytes) +{ + 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].component) ? &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->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+arr->offset); - array_type = GL_VERTEX_ARRAY; - } - else if(t==get_component_type(NORMAL3)) - { - if(arr) - glNormalPointer(GL_FLOAT, stride_bytes, base+arr->offset); - array_type = GL_NORMAL_ARRAY; - } - else if(t==get_component_type(COLOR4_FLOAT)) - { - if(arr) - { - if(sz==1) - glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+arr->offset); - else - glColorPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); - } - array_type = GL_COLOR_ARRAY; - } - else if(comp>=TEXCOORD1 && comp<=TEXCOORD4+12) - { - t -= get_component_type(TEXCOORD1); - if(t>0 || active_tex) - { - glClientActiveTexture(GL_TEXTURE0+t); - active_tex = t; - } - if(arr) - glTexCoordPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); - array_type = GL_TEXTURE_COORD_ARRAY; - } - else + + if(t>=get_component_type(ATTRIB1)) + t -= get_component_type(ATTRIB1); + if(arr) { - if(t>=get_component_type(ATTRIB1)) - t -= get_component_type(ATTRIB1); - if(arr) + if(arr->component==COLOR4_UBYTE) + glVertexAttribPointer(t, 4, GL_UNSIGNED_BYTE, true, stride_bytes, base+arr->offset); + else glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset); } // Only change enable state if needed if(arr && !old_arr) - { - if(array_type) - glEnableClientState(array_type); - else - glEnableVertexAttribArray(t); - } + glEnableVertexAttribArray(t); else if(old_arr && !arr) - { - if(array_type) - glDisableClientState(array_type); - else - glDisableVertexAttribArray(t); - } + glDisableVertexAttribArray(t); } +} - if(active_tex) - glClientActiveTexture(GL_TEXTURE0); - - if(vbuf) - Buffer::unbind_from(ARRAY_BUFFER); +void VertexArray::unbind() +{ + const VertexArray *old = current(); + if(set_current(0)) + apply_arrays(0, &old->arrays, 0, 0); } @@ -232,6 +180,27 @@ VertexArray::Array::Array(): VertexArray::Loader::Loader(VertexArray &a): VertexArrayBuilder(a) { + add("vertex", static_cast(&Loader::vertex)); + add("vertex", static_cast(&Loader::vertex)); + add("vertex", static_cast(&Loader::vertex)); + add("normal", static_cast(&Loader::normal)); + add("texcoord", static_cast(&Loader::texcoord)); + add("texcoord", static_cast(&Loader::texcoord)); + add("texcoord", static_cast(&Loader::texcoord)); + add("texcoord", static_cast(&Loader::texcoord)); + add("multitexcoord", static_cast(&Loader::multitexcoord)); + add("multitexcoord", static_cast(&Loader::multitexcoord)); + add("multitexcoord", static_cast(&Loader::multitexcoord)); + add("multitexcoord", static_cast(&Loader::multitexcoord)); + add("color", static_cast(&Loader::color)); + add("color", static_cast(&Loader::color)); + add("attrib", static_cast(&Loader::attrib)); + add("attrib", static_cast(&Loader::attrib)); + add("attrib", static_cast(&Loader::attrib)); + add("attrib", static_cast(&Loader::attrib)); + add("tangent", static_cast(&Loader::tangent)); + add("binormal", static_cast(&Loader::binormal)); + add("vertex2", static_cast(&Loader::vertex)); add("vertex3", static_cast(&Loader::vertex)); add("vertex4", static_cast(&Loader::vertex));