X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fbatch.cpp;h=f14cc307ff71b92deb212e9f759ac70f1c8d69f0;hp=33481a1cdfc8c613692f36de60e667e8413ed698;hb=bec07999d95b76f4b47cffcc564d0cd0afc0435e;hpb=927a1aa0a3a27e463ec0efc08bd08e7c4e969909 diff --git a/source/batch.cpp b/source/batch.cpp index 33481a1c..f14cc307 100644 --- a/source/batch.cpp +++ b/source/batch.cpp @@ -1,54 +1,239 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2007 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - +#include +#include #include "batch.h" -#include "extension.h" +#include "bindable.h" +#include "buffer.h" +#include "error.h" +#include "mesh.h" #include "vertexarray.h" using namespace std; +namespace { + +template +void append(vector &data, T i) +{ + data.insert(data.end(), sizeof(T), 0); + *(T *)(&data[data.size()-sizeof(T)]) = i; +} + +template +U convert(T n) +{ + if(!static_cast(~n)) + return ~0; + else + return n; +} + +template +void expand(vector &data) +{ + unsigned count = data.size()/sizeof(T); + data.resize(count*sizeof(U)); + for(unsigned i=count; i--;) + *(U *)(&data[i*sizeof(U)]) = convert(*(T *)(&data[i*sizeof(T)])); +} + +template +void shrink(vector &data) +{ + unsigned count = data.size()/sizeof(T); + for(unsigned i=0; i(*(T *)(&data[i*sizeof(T)])); + data.resize(count*sizeof(U)); +} + +} + namespace Msp { namespace GL { +unsigned Batch::restart_index = 0; + Batch::Batch(PrimitiveType t): - type(t), - min_index(0), - max_index(0) + prim_type(t), + index_type(UNSIGNED_SHORT), + max_index(0), + restart(false) { } -Batch &Batch::append(uint i) +Batch::~Batch() +{ +} + +void Batch::set_index_type(DataType t) +{ + if(t!=UNSIGNED_SHORT && t!=UNSIGNED_INT) + throw invalid_argument("Batch::set_data_type"); + if(t==UNSIGNED_SHORT && max_index>0xFFFE) + throw invalid_operation("Batch::set_data_type"); + + if(index_type==UNSIGNED_SHORT && t==UNSIGNED_INT) + expand(data); + else if(index_type==UNSIGNED_INT && t==UNSIGNED_SHORT) + shrink(data); + + index_type = t; + update_offset(); + dirty = true; +} + +Batch &Batch::append(unsigned i) +{ + append_index(i); + + update_offset(); + dirty = true; + + return *this; +} + +Batch &Batch::append(const vector &ind) +{ + if(ind.empty()) + return *this; + + data.reserve(data.size()+ind.size()*get_index_size()); + for(vector::const_iterator i=ind.begin(); i!=ind.end(); ++i) + append_index(*i); + + update_offset(); + dirty = true; + + return *this; +} + +bool Batch::can_append(PrimitiveType other_type) { - if(indices.empty()) - min_index=max_index=i; + if(other_type!=prim_type) + return false; + else if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN) + return MSP_primitive_restart; else + return true; +} + +Batch &Batch::append(const Batch &other) +{ + if(other.prim_type!=prim_type) + throw invalid_argument("Batch::append"); + if(prim_type==LINE_STRIP || prim_type==LINE_LOOP || prim_type==TRIANGLE_FAN) + static Require _req(MSP_primitive_restart); + + if(other.data.empty()) + return *this; + + // TODO allow appending triangles to a triangle strip + + if(prim_type==POINTS || prim_type==LINES || prim_type==TRIANGLES) + ; + else if(MSP_primitive_restart) + { + restart = true; + if(index_type==UNSIGNED_INT) + ::append(data, 0xFFFFFFFF); + else + ::append(data, 0xFFFF); + } + else if(prim_type==TRIANGLE_STRIP) { - min_index=min(min_index, i); - max_index=max(max_index, i); + append(get_index(size()-1)); + append(other.get_index(0)); + if(size()&1) + append(other.get_index(0)); } - indices.push_back(i); + + unsigned count = other.size(); + for(unsigned i=0; i &ind) +void Batch::append_index(unsigned i) +{ + if(data.empty()) + max_index = i; + else + max_index = max(max_index, i); + + if(index_type==UNSIGNED_SHORT && max_index>0xFFFE) + set_index_type(UNSIGNED_INT); + + if(index_type==UNSIGNED_INT) + ::append(data, i); + else + ::append(data, i); +} + +unsigned Batch::get_index_size() const +{ + return (index_type==UNSIGNED_INT ? sizeof(UInt32) : sizeof(UInt16)); +} + +unsigned Batch::get_index(unsigned i) const { - indices.reserve(indices.size()+ind.size()); - for(vector::const_iterator i=ind.begin(); i!=ind.end(); ++i) - append(*i); + if(index_type==UNSIGNED_INT) + return *(UInt32 *)&data[i*sizeof(UInt32)]; + else + return *(UInt16 *)&data[i*sizeof(UInt16)]; } void Batch::draw() const { - draw_range_elements(type, min_index, max_index, indices.size(), &indices[0]); + BindRestore _bind_ibuf(get_buffer(), ELEMENT_ARRAY_BUFFER); + const void *data_ptr = setup_draw(); + + glDrawElements(prim_type, size(), index_type, data_ptr); +} + +void Batch::draw_instanced(unsigned count) const +{ + static Require req(ARB_draw_instanced); + + BindRestore _bind_ibuf(get_buffer(), ELEMENT_ARRAY_BUFFER); + const void *data_ptr = setup_draw(); + + glDrawElementsInstanced(prim_type, size(), index_type, data_ptr, count); +} + +const void *Batch::setup_draw() const +{ + if(!get_buffer()) + throw invalid_operation("Batch::setup_draw"); + + if(restart) + { + unsigned index = (index_type==UNSIGNED_INT ? 0xFFFFFFFF : 0xFFFF); + + if(index!=restart_index) + set_restart_index(index); + } + else if(restart_index && restart_index<=max_index) + set_restart_index(0); + + refresh(); + + return reinterpret_cast(get_offset()); } -void Batch::draw_with_buffer(unsigned offset) const +void Batch::set_restart_index(unsigned index) { - draw_range_elements(type, min_index, max_index, indices.size(), (unsigned *)0+offset); + if(index>0) + { + if(!restart_index) + glEnable(GL_PRIMITIVE_RESTART); + glPrimitiveRestartIndex(index); + } + else + glDisable(GL_PRIMITIVE_RESTART); + + restart_index = index; } @@ -58,7 +243,7 @@ Batch::Loader::Loader(Batch &b): add("indices", &Loader::indices); } -void Batch::Loader::indices(const vector &ind) +void Batch::Loader::indices(const vector &ind) { obj.append(ind); }