X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;ds=sidebyside;f=source%2Fvertexarray.cpp;h=f3476268b8c5c30071ba70a7c14c9e349d6a9359;hb=f14435e58bfa0fa697a06ba9a454bb30cd37d9d8;hp=a2d3936c35f9532b3cc73087b24f9a5e19fe8a55;hpb=f71aee8c20ff85e4857e4dfad0c20ce606ea3717;p=libs%2Fgl.git diff --git a/source/vertexarray.cpp b/source/vertexarray.cpp index a2d3936c..f3476268 100644 --- a/source/vertexarray.cpp +++ b/source/vertexarray.cpp @@ -1,51 +1,49 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - -#include +#include "arb_vertex_program.h" +#include "buffer.h" +#include "extension.h" +#include "gl.h" +#include "version_1_2.h" +#include "version_1_3.h" #include "vertexarray.h" -#include "vertexbuffer.h" using namespace std; namespace Msp { namespace GL { -VertexArray::VertexArray(VertexFormat f): - format(NODATA), - stride(get_stride(f)), - vbuf(0), - own_vbuf(false) +VertexArray::ArrayMask VertexArray::enabled_arrays; + +VertexArray::VertexArray(const VertexFormat &f): + defer_vbuf(true), + dirty(false) { - // Reverse the format so the first item is in lowest bits. This makes handling in bind() easier. - for(uint fmt=f; fmt; fmt>>=4) - format=(format, static_cast(fmt&15)); + reset(f); } VertexArray::~VertexArray() -{ - if(own_vbuf) - delete vbuf; -} +{ } void VertexArray::use_vertex_buffer() { - if(vbuf) return; + if(vbuf) + return; - vbuf=new VertexBuffer(); - own_vbuf=true; - update_data(); + vbuf = new Buffer(ARRAY_BUFFER); + defer_vbuf = false; + dirty = true; } -void VertexArray::use_vertex_buffer(VertexBuffer *b) +void VertexArray::use_vertex_buffer(Buffer *b) { - if(vbuf) return; + vbuf = b; + vbuf.keep(); + defer_vbuf = false; + dirty = true; +} - vbuf=b; - update_data(); +void VertexArray::reserve(unsigned n) +{ + data.reserve(n*stride); } void VertexArray::clear() @@ -53,92 +51,168 @@ void VertexArray::clear() data.clear(); } -void VertexArray::reset(VertexFormat f) +void VertexArray::reset(const VertexFormat &f) { clear(); - format=NODATA; - for(uint fmt=f; fmt; fmt>>=4) - format=(format, static_cast(fmt&15)); - stride=get_stride(format); -} + format = f; + stride = get_stride(format); -RefPtr VertexArray::modify() -{ - return new VertexArrayBuilder(*this, data); + bool has_multitex = false; + bool has_gen_attrs = false; + for(const unsigned char *c=format.begin(); c!=format.end(); ++c) + { + if(*c>=TEXCOORD1+4 && *c=ATTRIB1) + has_gen_attrs = true; + } + 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==NODATA) - throw InvalidState("Trying to apply a vertex apply of format NODATA"); + if(format.empty()) + throw InvalidState("Trying to apply a vertex array with no data"); if(vbuf) - vbuf->bind(); + { + vbuf->bind_to(ARRAY_BUFFER); + if(dirty) + { + vbuf->data(data.size()*sizeof(float), &data[0]); + dirty = false; + } + } - const float *base=vbuf?0:&data[0]; - uint offset=0; - uint found=0; - for(uint fmt=format; fmt; fmt>>=4) + const float *base = (vbuf ? 0 : &data[0]); + unsigned offset = 0; + ArrayMask found; + unsigned bpv = stride*sizeof(float); + unsigned active_tex = 0; + for(const unsigned char *c=format.begin(); c!=format.end(); ++c) { - uint size=(fmt&3)+1; - switch(fmt&12) + unsigned sz = (*c&3)+1; + unsigned t = *c>>2; + bool en = enabled_arrays.is_set(t); + switch(t) { case 0: - glVertexPointer(size, GL_FLOAT, stride, base+offset); + glVertexPointer(sz, GL_FLOAT, bpv, base+offset); + if(!en) + glEnableClientState(GL_VERTEX_ARRAY); break; - case 4: - glNormalPointer(GL_FLOAT, stride, base+offset); + case 1: + glNormalPointer(GL_FLOAT, bpv, base+offset); + if(!en) + glEnableClientState(GL_NORMAL_ARRAY); break; - case 8: - glTexCoordPointer(size, GL_FLOAT, stride, base+offset); + 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; - case 12: - if(size==1) - glColorPointer(4, GL_UNSIGNED_BYTE, stride, base+offset); + default: + if(t<11) + { + 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); + } else - glColorPointer(size, GL_FLOAT, stride, base+offset); + { + glVertexAttribPointerARB(t-11, sz, GL_FLOAT, false, bpv, base+offset); + if(!en) + glEnableVertexAttribArrayARB(t-11); + } break; } - found|=1<<((fmt&12)>>2); - offset+=size; + found.set(t); + offset += sz; } - set_array(GL_VERTEX_ARRAY, found&1, 1); - set_array(GL_NORMAL_ARRAY, found&2, 2); - set_array(GL_TEXTURE_COORD_ARRAY, found&4, 4); - set_array(GL_COLOR_ARRAY, found&8, 8); + for(unsigned i=0; i<64; ++i) + if(enabled_arrays.is_set(i) && !found.is_set(i)) + { + 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); + active_tex = i-3; + } + else + glDisableVertexAttribArrayARB(i-11); + } - VertexBuffer::unbind(); + enabled_arrays = found; + + if(active_tex) + glClientActiveTexture(GL_TEXTURE0); + + if(vbuf) + Buffer::unbind_from(ARRAY_BUFFER); } -/** -Updates the VertexArray data to the VertexBuffer tied to the array, if any. -*/ -void VertexArray::update_data() +float *VertexArray::append() { - if(vbuf) - vbuf->data(data.size()*sizeof(float), &data[0]); + data.insert(data.end(), stride, 0.0f); + set_dirty(); + return &*(data.end()-stride); } -void VertexArray::set_array(unsigned array, unsigned bit, unsigned mask) const +float *VertexArray::modify(unsigned i) { - if((enabled_arrays&mask) && !bit) - { - glDisableClientState(array); - enabled_arrays&=~mask; - } - else if(!(enabled_arrays&mask) && bit) + set_dirty(); + return &data[0]+i*stride; +} + +void VertexArray::set_dirty() +{ + dirty = true; + if(defer_vbuf) { - glEnableClientState(array); - enabled_arrays|=mask; + vbuf = new Buffer(ARRAY_BUFFER); + defer_vbuf = false; } } -unsigned VertexArray::enabled_arrays=0; + +VertexArray::ArrayMask::ArrayMask() +{ + for(unsigned i=0; i(&Loader::vertex)); add("vertex3", static_cast(&Loader::vertex)); @@ -148,8 +222,38 @@ 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); } } // namespace GL