X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fvertexarray.cpp;h=5674bbe0ddda48472cc0423b5230fe754710b3fc;hp=8381d8adb1d9663b742db5a88af857f988b6bfd0;hb=97b8f0d945474582c2213b70418d399e5641f0d5;hpb=b617c5d7b5283ad260a77f01e42e6170cabbc03d diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index 8381d8ad..5674bbe0 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -1,54 +1,87 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007-2009 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include "arb_vertex_program.h" -#include "extension.h" +#include +#include +#include +#include "buffer.h" +#include "error.h" #include "gl.h" -#include "version_1_2.h" +#include "mesh.h" #include "vertexarray.h" -#include "vertexbuffer.h" using namespace std; namespace Msp { namespace GL { -VertexArray::VertexArray(const VertexFormat &f): - vbuf(0), - own_vbuf(false) +bool VertexArray::legacy_used = false; + +VertexArray::VertexArray(const VertexFormat &f) { reset(f); } VertexArray::~VertexArray() { - if(own_vbuf) - delete vbuf; + /* Unbind accesses the current VertexArray, so a call from ~Bindable would + try to access destroyed data. */ + if(current()==this) + unbind(); } -void VertexArray::use_vertex_buffer() +void VertexArray::reset(const VertexFormat &f) { - if(vbuf && own_vbuf) - return; + clear(); + format = f; + stride = get_stride(format); + legacy = false; - vbuf = new Buffer(ARRAY_BUFFER); - own_vbuf = true; + arrays.clear(); - update_data(); + 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); + + Array &arr = arrays[slot]; + arr.component = *c; + arr.offset = offs; + + if(*c=TEXCOORD1 && comp<=TEXCOORD4+12) + { + t -= get_component_type(TEXCOORD1); + if(t>0) + static Require _req(ARB_multitexture); + return 3+t; + } + else + { + static Require _req(ARB_vertex_shader); + if(comp>=ATTRIB1) + t -= get_component_type(ATTRIB1); + return 7+t; + } +} - update_data(); +void VertexArray::clear() +{ + data.clear(); } void VertexArray::reserve(unsigned n) @@ -56,115 +89,164 @@ void VertexArray::reserve(unsigned n) data.reserve(n*stride); } -void VertexArray::clear() +float *VertexArray::append() { - data.clear(); + data.insert(data.end(), stride, 0.0f); + update_offset(); + dirty = true; + return &*(data.end()-stride); } -void VertexArray::reset(const VertexFormat &f) +float *VertexArray::modify(unsigned i) { - clear(); - format = f; - stride = get_stride(format); + dirty = true; + return &data[0]+i*stride; +} - bool has_gen_attrs = false; - for(const unsigned char *c=format.begin(); (!has_gen_attrs && c!=format.end()); ++c) - has_gen_attrs = (*c>=ATTRIB1); - if(has_gen_attrs) - static RequireExtension _ext("GL_ARB_vertex_program"); +unsigned VertexArray::get_data_size() const +{ + return data.size()*sizeof(float); } -void VertexArray::apply() const +void VertexArray::apply(bool use_legacy) const { if(format.empty()) - throw InvalidState("Trying to apply a vertex array with no data"); + throw invalid_operation("VertexArray::apply"); + // Don't mess up the vertex array object of a mesh + if(Mesh::current()) + throw invalid_operation("VertexArray::apply"); + + /* Unbind first if the legacy flag changes. The logic for supporting it + directly in apply_arrays would get too complicated, and this also allows + rebinding the same array with different legacy setting. */ + if(legacy_used!=use_legacy) + unbind(); + + if(!use_legacy) + static Require _req(ARB_vertex_shader); + else if(legacy) + static Require _req(MSP_legacy_features); + + const VertexArray *old = current(); + /* 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(); + Buffer *vbuf = get_buffer(); + Bind _bind_vbuf(vbuf, ARRAY_BUFFER); + if(vbuf && dirty) + update_buffer(); - const float *base = vbuf?0:&data[0]; - unsigned offset = 0; - unsigned found = 0; - unsigned bpv = stride*sizeof(float); - for(const unsigned char *c=format.begin(); c!=format.end(); ++c) + 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, use_legacy); +} + +void VertexArray::apply_arrays(const vector *arrays, const vector *old_arrays, const float *base, unsigned stride_bytes, bool use_legacy) +{ + unsigned active_tex = 0; + unsigned n_arrays = arrays ? arrays->size() : 0; + if(old_arrays) + n_arrays = max(n_arrays, old_arrays->size()); + for(unsigned i=0; i>2; - switch(t) + 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); + if(use_legacy) { - case 0: - glVertexPointer(sz, GL_FLOAT, bpv, base+offset); - break; - case 1: - glNormalPointer(GL_FLOAT, bpv, base+offset); - break; - case 2: - glTexCoordPointer(sz, GL_FLOAT, bpv, base+offset); - break; - case 3: - if(sz==1) - glColorPointer(4, GL_UNSIGNED_BYTE, bpv, base+offset); + 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; + } + + if(array_type) + { + // Only change enable state if needed + if(arr && !old_arr) + glEnableClientState(array_type); + else if(old_arr && !arr) + glDisableClientState(array_type); + + continue; + } + } + + 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 - glColorPointer(sz, GL_FLOAT, bpv, base+offset); - break; - default: - glVertexAttribPointerARB(t-4, sz, GL_FLOAT, false, bpv, base+offset); - break; + glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset); } - found |= 1<>i)&1, 1<unbind(); + legacy_used = use_legacy; } -/** -Updates the VertexArray data to the VertexBuffer tied to the array, if any. -*/ -void VertexArray::update_data() +void VertexArray::unbind() { - if(vbuf) - { - vbuf->data(data.size()*sizeof(float), &data[0]); - vbuf->unbind(); - } + const VertexArray *old = current(); + if(set_current(0)) + apply_arrays(0, &old->arrays, 0, 0, legacy_used); } -float *VertexArray::append() -{ - data.insert(data.end(), stride, 0.0f); - return &*data.end()-stride; -} -void VertexArray::set_array(unsigned array, bool en, unsigned mask) const -{ - if((enabled_arrays&mask) && !en) - { - if(mask<16) - glDisableClientState(array); - else - glDisableVertexAttribArrayARB(array); - enabled_arrays &= ~mask; - } - else if(!(enabled_arrays&mask) && en) - { - if(mask<16) - glEnableClientState(array); - else - glEnableVertexAttribArrayARB(array); - enabled_arrays |= mask; - } -} - -unsigned VertexArray::enabled_arrays = 0; +VertexArray::Array::Array(): + component(0), + offset(0) +{ } VertexArray::Loader::Loader(VertexArray &a): @@ -178,34 +260,18 @@ VertexArray::Loader::Loader(VertexArray &a): add("texcoord2", static_cast(&Loader::texcoord)); add("texcoord3", static_cast(&Loader::texcoord)); add("texcoord4", static_cast(&Loader::texcoord)); + add("multitexcoord1", static_cast(&Loader::multitexcoord)); + add("multitexcoord2", static_cast(&Loader::multitexcoord)); + add("multitexcoord3", static_cast(&Loader::multitexcoord)); + add("multitexcoord4", static_cast(&Loader::multitexcoord)); add("color3", static_cast(&Loader::color)); add("color4", static_cast(&Loader::color)); add("attrib1", static_cast(&Loader::attrib)); add("attrib2", static_cast(&Loader::attrib)); add("attrib3", static_cast(&Loader::attrib)); add("attrib4", static_cast(&Loader::attrib)); -} - - -void array_element(int i) -{ - glArrayElement(i); -} - -void draw_arrays(PrimitiveType mode, int first, unsigned count) -{ - glDrawArrays(mode, first, count); -} - -void draw_elements(PrimitiveType mode, unsigned count, DataType type, const void *indices) -{ - glDrawElements(mode, count, type, indices); -} - -void draw_range_elements(PrimitiveType mode, unsigned low, unsigned high, unsigned count, DataType type, const void *indices) -{ - static RequireVersion _ver(1, 2); - glDrawRangeElements(mode, low, high, count, type, indices); + add("tangent3", static_cast(&Loader::tangent)); + add("binormal3", static_cast(&Loader::binormal)); } } // namespace GL