X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fcore%2Fvertexformat.cpp;h=7dcb7aba5472e9438671ef31da1036ef15276c8b;hp=2ce02e2edc693189ee0a84f50426d40dc8c6b0ba;hb=e92de029768eef5f0fd744329e589161b46d0762;hpb=e1d07383b29e8581230b50f45606192d1f21f5dd diff --git a/source/core/vertexformat.cpp b/source/core/vertexformat.cpp index 2ce02e2e..7dcb7aba 100644 --- a/source/core/vertexformat.cpp +++ b/source/core/vertexformat.cpp @@ -1,11 +1,10 @@ #include +#include #include #include #include #include "error.h" -#include "misc.h" #include "vertexformat.h" -#include using namespace std; @@ -33,13 +32,25 @@ VertexFormat VertexFormat::operator,(VertexAttribute a) const return r; } +VertexFormat VertexFormat::operator,(DataType t) const +{ + if(!count) + throw invalid_operation("VertexFormat::operator,"); + + VertexFormat r = *this; + UInt16 &a = r.attributes[r.count-1]; + a = make_typed_attribute(static_cast(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]; + UInt16 &a = r.attributes[r.count-1]; a = make_indexed_attribute(static_cast(a), i); return r; @@ -55,7 +66,7 @@ bool VertexFormat::operator==(const VertexFormat &other) const unsigned VertexFormat::stride() const { unsigned s = 0; - for(const unsigned char *i=begin(); i!=end(); ++i) + for(const UInt16 *i=begin(); i!=end(); ++i) s += get_attribute_size(*i); return s; } @@ -63,13 +74,13 @@ unsigned VertexFormat::stride() const 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(const UInt16 *i=begin(); i!=end(); ++i) { if(get_attribute_semantic(*i)==sem) { - if(get_attribute_size(*i)>=sz) + if(get_attribute_source_type(*i)==get_attribute_source_type(attr) && + get_attribute_component_count(*i)>=get_attribute_component_count(attr)) return offs; else return -1; @@ -82,72 +93,116 @@ int VertexFormat::offset(VertexAttribute attr) const } +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) { unsigned base = attr; - if(attr>=TEXCOORD1 && attr<=TEXCOORD4) + if(get_attribute_semantic(attr)==get_attribute_semantic(TEXCOORD1)) { if(index>=4) throw out_of_range("make_indexed_attribute"); } - else if(attr>=RAW_ATTRIB1 && attr<=RAW_ATTRIB4) - base &= 7; - else if(attrGENERIC4) + else if(get_attribute_semantic(attr)==get_attribute_semantic(RAW_ATTRIB1)) + base &= 0x3FF; + else if(get_attribute_semantic(attr)!=get_attribute_semantic(GENERIC1)) throw invalid_argument("make_indexed_attribute"); - static int max_attribs = -1; - if(max_attribs<0) - max_attribs = get_i(GL_MAX_VERTEX_ATTRIBS); - - if(static_cast((base>>3)+index)>=max_attribs) + if(get_attribute_semantic(base)+index>=63) throw out_of_range("make_indexed_attribute"); - return static_cast(base+index*8); + 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()==6 && !str.compare(0, 5, "GROUP") && str[5]>='1' && str[5]<='4') - a = static_cast(GROUP1+(str[5]-'1')); - else if(str.size()==7 && !str.compare(0, 6, "WEIGHT") && str[6]>='1' && str[6]<='4') - a = static_cast(WEIGHT1+(str[6]-'1')); - else if(str.size()>=9 && !str.compare(0, 8, "TEXCOORD") && str[8]>='1' && str[8]<='4') + string::const_iterator 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) +{ + string::const_iterator 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]<='3') - a = make_indexed_attribute(static_cast(TEXCOORD1+(str[8]-'1')), str[10]-'0'); - 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()>=10 && !str.compare(0, 6, "GENERIC") && str[7]>='1' && str[7]<='4' && str[8]=='_') + + 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(9)); - } - 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 = make_indexed_attribute(static_cast(GENERIC1+(str[7]-'1')), n); + 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; + } + + 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; } - else - throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); + catch(...) + { } + + throw lexical_error(format("conversion of '%s' to VertexAttribute", str)); } } // namespace GL