X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fcore%2Fvertexformat.cpp;h=ff043f7d0466bef73b08e216836617ef8fe9200f;hp=05364be81ae8075c55102c29c2d0c892fb9094c3;hb=38712d8ecc57d043a2419ffbaeeb57f7a6586f14;hpb=ea7832c7c1ffab00cc1168bc8c41375fdd0eae86 diff --git a/source/core/vertexformat.cpp b/source/core/vertexformat.cpp index 05364be8..ff043f7d 100644 --- a/source/core/vertexformat.cpp +++ b/source/core/vertexformat.cpp @@ -1,7 +1,4 @@ -#include #include -#include -#include #include "error.h" #include "vertexformat.h" @@ -10,10 +7,6 @@ using namespace std; namespace Msp { namespace GL { -VertexFormat::VertexFormat(): - count(0) -{ } - VertexFormat::VertexFormat(VertexAttribute a): count(1) { @@ -31,14 +24,26 @@ VertexFormat VertexFormat::operator,(VertexAttribute a) const return r; } +VertexFormat VertexFormat::operator,(DataType t) const +{ + if(!count) + throw invalid_operation("VertexFormat::operator,"); + + VertexFormat r = *this; + VertexAttribute &a = r.attributes[r.count-1]; + a = make_typed_attribute(a, t); + + return r; +} + VertexFormat VertexFormat::operator,(unsigned i) const { if(!count) throw invalid_operation("VertexFormat::operator,"); VertexFormat r = *this; - unsigned char &a = r.attributes[r.count-1]; - a = make_indexed_attribute(static_cast(a), i); + VertexAttribute &a = r.attributes[r.count-1]; + a = make_indexed_attribute(a, i); return r; } @@ -53,89 +58,143 @@ bool VertexFormat::operator==(const VertexFormat &other) const unsigned VertexFormat::stride() const { unsigned s = 0; - for(const unsigned char *i=begin(); i!=end(); ++i) - s += get_attribute_size(*i); + for(VertexAttribute a: *this) + s += get_attribute_size(a); return s; } int VertexFormat::offset(VertexAttribute attr) const { unsigned sem = get_attribute_semantic(attr); - unsigned sz = get_attribute_size(attr); unsigned offs = 0; - for(const unsigned char *i=begin(); i!=end(); ++i) + for(VertexAttribute a: *this) { - if(get_attribute_semantic(*i)==sem) + if(get_attribute_semantic(a)==sem) { - if(get_attribute_size(*i)>=sz) + if(get_attribute_source_type(a)==get_attribute_source_type(attr) && + get_attribute_component_count(a)>=get_attribute_component_count(attr)) return offs; else return -1; } else - offs += get_attribute_size(*i); + offs += get_attribute_size(a); } return -1; } +VertexAttribute make_typed_attribute(VertexAttribute attr, DataType type) +{ + if(is_matrix(type) || is_vector(type) || is_image(type)) + throw invalid_argument("make_typed_attribute"); + if(is_integer_attribute(attr) && is_float(type)) + throw invalid_argument("make_typed_attribute"); + + return static_cast((attr&0xFC0F) | (type&0x0F)<<4 | (type&0x300)>>1); +} + VertexAttribute make_indexed_attribute(VertexAttribute attr, unsigned index) { - if(attr>=TEXCOORD1 && attr<=TEXCOORD4) + VertexAttribute base = attr; + if(get_attribute_semantic(attr)==get_attribute_semantic(TEXCOORD1)) { if(index>=4) throw out_of_range("make_indexed_attribute"); } - else if(attr>=ATTRIB1 && attr<=ATTRIB4) - { - if(index>=24) - throw out_of_range("make_indexed_attribute"); - } - else + else if(get_attribute_semantic(attr)==get_attribute_semantic(RAW_ATTRIB1)) + base = static_cast(base&0x3FF); + else if(get_attribute_semantic(attr)!=get_attribute_semantic(GENERIC1)) throw invalid_argument("make_indexed_attribute"); - return static_cast(attr+index*4); + + if(get_attribute_semantic(base)+index>=63) + throw out_of_range("make_indexed_attribute"); + + return static_cast(base+(index<<10)); } -void operator>>(const LexicalConverter &conv, VertexAttribute &a) + +bool convert_attribute_type(string::const_iterator &i, string::const_iterator end, const char *name, VertexAttribute &attr, DataType type) { - const string &str = conv.get(); - if(str.size()==7 && !str.compare(0, 6, "VERTEX") && str[6]>='2' && str[6]<='4') - a = static_cast(VERTEX2+(str[6]-'2')); - else if(str=="NORMAL3") - a = NORMAL3; - else if(str.size()==12 && !str.compare(0, 5, "COLOR") && str[5]>='3' && str[5]<='4' && !str.compare(6, 6, "_FLOAT")) - a = static_cast(COLOR3_FLOAT+(str[5]-'3')); - else if(str=="COLOR4_UBYTE") - a = COLOR4_UBYTE; - else if(str=="TANGENT3") - a = TANGENT3; - else if(str=="BINORMAL3") - a = BINORMAL3; - else if(str.size()>=9 && !str.compare(0, 8, "TEXCOORD") && str[8]>='1' && str[8]<='4') + auto j = i; + for(; (j!=end && *j!='_' && *name); ++name, ++j) + if(*j!=*name) + return false; + + attr = make_typed_attribute(attr, type); + i = j; + + return true; +} + +bool convert_attribute(const string &str, const char *name, int min_size, int max_size, VertexAttribute &attr, VertexAttribute base_attr) +{ + auto i = str.begin(); + for(; *name; ++name, ++i) + if(*i!=*name) + return false; + + VertexAttribute result = base_attr; + + if(i!=str.end() && *i=='_') { - if(str.size()==9) - a = static_cast(TEXCOORD1+(str[8]-'1')); - else if(str.size()==11 && str[9]=='_' && str[10]>='0' && str[10]<='7') - a = static_cast(TEXCOORD1+(str[8]-'1')+(str[10]-'0')*4); - else - throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); + if(*(++i)++!='I') + return false; + result = static_cast(result|8); } - else if(str.size()>=9 && !str.compare(0, 6, "ATTRIB") && str[6]>='1' && str[6]<='4' && str[7]=='_') + + if(i==str.end() || *i<'0'+min_size || *i>'0'+max_size) + return false; + result = static_cast(result+(*i++-'0'-min_size)); + + while(i!=str.end()) { - unsigned n; - try - { - n = lexical_cast(str.substr(8)); - } - catch(const lexical_error &) + if(*i!='_' || ++i==str.end()) + return false; + + if(isdigit(*i)) { - throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); + unsigned index = 0; + for(; (i!=str.end() && isdigit(*i)); ++i) + index = index*10+(*i-'0'); + result = make_indexed_attribute(result, index); } - a = static_cast(ATTRIB1+(str[6]-'1')+n*4); + else if(convert_attribute_type(i, str.end(), "UBYTE", result, UNSIGNED_BYTE) || + convert_attribute_type(i, str.end(), "BYTE", result, BYTE) || + convert_attribute_type(i, str.end(), "USHORT", result, UNSIGNED_SHORT) || + convert_attribute_type(i, str.end(), "SHORT", result, SHORT) || + convert_attribute_type(i, str.end(), "UINT", result, UNSIGNED_INT) || + convert_attribute_type(i, str.end(), "INT", result, INT) || + convert_attribute_type(i, str.end(), "FLOAT", result, FLOAT)) + ; + else + return false; } - else - throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); + + attr = result; + return true; +} + +void operator>>(const LexicalConverter &conv, VertexAttribute &a) +{ + const string &str = conv.get(); + try + { + if(convert_attribute(str, "VERTEX", 2, 4, a, VERTEX2) || + convert_attribute(str, "COLOR", 3, 4, a, COLOR3) || + convert_attribute(str, "NORMAL", 3, 3, a, NORMAL3) || + convert_attribute(str, "TANGENT", 3, 3, a, TANGENT3) || + convert_attribute(str, "GROUP", 1, 4, a, GROUP1) || + convert_attribute(str, "WEIGHT", 1, 4, a, WEIGHT1) || + convert_attribute(str, "TEXCOORD", 1, 4, a, TEXCOORD1) || + convert_attribute(str, "GENERIC", 1, 4, a, GENERIC1)) + return; + } + catch(...) + { } + + throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); } } // namespace GL