X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fvertexarray.cpp;h=5065f305c3575920411b6d8ebfc707f61b6aabb3;hb=619aae12e01f25e79626a94c973927e5599e99a5;hp=54de0c0d1d01beadef6228a8bb29fd7ab7a5e66f;hpb=85c82f93f4874bcf0b04332c9abb62cd2a5b181b;p=libs%2Fgl.git diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index 54de0c0d..5065f305 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -1,16 +1,8 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007-2010 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include "arb_vertex_program.h" +#include +#include #include "buffer.h" -#include "extension.h" +#include "error.h" #include "gl.h" -#include "version_1_2.h" -#include "version_1_3.h" #include "vertexarray.h" using namespace std; @@ -18,8 +10,6 @@ using namespace std; namespace Msp { namespace GL { -VertexArray::ArrayMask VertexArray::enabled_arrays; - VertexArray::VertexArray(const VertexFormat &f): defer_vbuf(true), dirty(false) @@ -28,7 +18,63 @@ VertexArray::VertexArray(const VertexFormat &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) +{ + clear(); + format = f; + stride = get_stride(format); + + arrays.clear(); + + unsigned offset = 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 = offset; + + offset += get_component_size(*c); + } +} + +unsigned VertexArray::get_array_slot(unsigned char comp) +{ + unsigned t = get_component_type(comp); + if(t==get_component_type(VERTEX3)) + return 0; + else if(t==get_component_type(NORMAL3)) + return 1; + else if(t==get_component_type(COLOR4_FLOAT)) + return 2; + else if(comp>=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; + } +} void VertexArray::use_vertex_buffer() { @@ -48,41 +94,51 @@ void VertexArray::use_vertex_buffer(Buffer *b) dirty = true; } +void VertexArray::clear() +{ + data.clear(); +} + void VertexArray::reserve(unsigned n) { data.reserve(n*stride); } -void VertexArray::clear() +float *VertexArray::append() { - data.clear(); + data.insert(data.end(), stride, 0.0f); + set_dirty(); + return &*(data.end()-stride); } -void VertexArray::reset(const VertexFormat &f) +float *VertexArray::modify(unsigned i) { - clear(); - format = f; - stride = get_stride(format); + set_dirty(); + return &data[0]+i*stride; +} - bool has_multitex = false; - bool has_gen_attrs = false; - for(const unsigned char *c=format.begin(); c!=format.end(); ++c) +void VertexArray::set_dirty() +{ + dirty = true; + if(defer_vbuf) { - if(*c>=TEXCOORD1+4 && *c=ATTRIB1) - has_gen_attrs = true; + vbuf = new Buffer(ARRAY_BUFFER); + defer_vbuf = false; } - if(has_multitex) - static RequireVersion _ver(1, 3); - if(has_gen_attrs) - static RequireExtension _ext("GL_ARB_vertex_program"); } void VertexArray::apply() const { if(format.empty()) - throw InvalidState("Trying to apply a vertex array with no data"); + throw invalid_operation("VertexArray::apply"); + + 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) { @@ -95,126 +151,99 @@ void VertexArray::apply() const } const float *base = (vbuf ? 0 : &data[0]); - unsigned offset = 0; - ArrayMask found; - unsigned bpv = stride*sizeof(float); + 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; - for(const unsigned char *c=format.begin(); c!=format.end(); ++c) + unsigned n_arrays = arrays ? arrays->size() : 0; + if(old_arrays) + n_arrays = max(n_arrays, old_arrays->size()); + for(unsigned i=0; i>2; - bool en = enabled_arrays.is_set(t); - 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); + GLenum array_type = 0; + if(t==get_component_type(VERTEX3)) { - case 0: - glVertexPointer(sz, GL_FLOAT, bpv, base+offset); - if(!en) - glEnableClientState(GL_VERTEX_ARRAY); - break; - case 1: - glNormalPointer(GL_FLOAT, bpv, base+offset); - if(!en) - glEnableClientState(GL_NORMAL_ARRAY); - break; - case 2: - if(sz==1) - glColorPointer(4, GL_UNSIGNED_BYTE, bpv, base+offset); - else - glColorPointer(sz, GL_FLOAT, bpv, base+offset); - if(!en) - glEnableClientState(GL_COLOR_ARRAY); - break; - default: - if(t<11) + 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(t>3 || active_tex) - { - glClientActiveTexture(GL_TEXTURE0+(t-3)); - active_tex = t-3; - } - glTexCoordPointer(sz, GL_FLOAT, bpv, base+offset); - if(!en) - glEnableClientState(GL_TEXTURE_COORD_ARRAY); + if(sz==1) + glColorPointer(4, GL_UNSIGNED_BYTE, stride_bytes, base+arr->offset); + else + glColorPointer(sz, GL_FLOAT, stride_bytes, base+arr->offset); } - else + array_type = GL_COLOR_ARRAY; + } + else if(comp>=TEXCOORD1 && comp<=TEXCOORD4+12) + { + t -= get_component_type(TEXCOORD1); + if(t>0 || active_tex) { - glVertexAttribPointerARB(t-11, sz, GL_FLOAT, false, bpv, base+offset); - if(!en) - glEnableVertexAttribArrayARB(t-11); + glClientActiveTexture(GL_TEXTURE0+t); + active_tex = t; } - break; + 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) + glVertexAttribPointer(t, sz, GL_FLOAT, false, stride_bytes, base+arr->offset); } - found.set(t); - offset += sz; - } - for(unsigned i=0; i<64; ++i) - if(enabled_arrays.is_set(i) && !found.is_set(i)) + // Only change enable state if needed + if(arr && !old_arr) { - if(i==0) - glDisableClientState(GL_VERTEX_ARRAY); - else if(i==1) - glDisableClientState(GL_NORMAL_ARRAY); - else if(i==2) - glDisableClientState(GL_COLOR_ARRAY); - else if(i>=3 && i<11) - { - if(i>3 || active_tex) - glClientActiveTexture(GL_TEXTURE0+(i-3)); - glDisableClientState(GL_TEXTURE_COORD_ARRAY); - } + if(array_type) + glEnableClientState(array_type); else - glDisableVertexAttribArrayARB(i-11); + glEnableVertexAttribArray(t); } - - enabled_arrays = found; + else if(old_arr && !arr) + { + if(array_type) + glDisableClientState(array_type); + else + glDisableVertexAttribArray(t); + } + } if(active_tex) glClientActiveTexture(GL_TEXTURE0); - - if(vbuf) - Buffer::unbind_from(ARRAY_BUFFER); -} - -float *VertexArray::append() -{ - data.insert(data.end(), stride, 0.0f); - set_dirty(); - return &*(data.end()-stride); } -float *VertexArray::modify(unsigned i) -{ - set_dirty(); - return &data[0]+i*stride; -} -void VertexArray::set_dirty() -{ - dirty = true; - if(defer_vbuf) - { - vbuf = new Buffer(ARRAY_BUFFER); - defer_vbuf = false; - } -} - - -VertexArray::ArrayMask::ArrayMask() -{ - for(unsigned i=0; i(&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