diff options
Diffstat (limited to 'core/io/marshalls.cpp')
| -rw-r--r-- | core/io/marshalls.cpp | 1117 |
1 files changed, 534 insertions, 583 deletions
diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp index a8c1cd0a10..927ce31744 100644 --- a/core/io/marshalls.cpp +++ b/core/io/marshalls.cpp @@ -27,99 +27,96 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "marshalls.h" -#include "print_string.h" #include "os/keyboard.h" +#include "print_string.h" #include <stdio.h> +#define ENCODE_MASK 0xFF +#define ENCODE_FLAG_64 1 << 16 -#define ENCODE_MASK 0xFF -#define ENCODE_FLAG_64 1<<16 +Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int *r_len) { -Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int *r_len) { + const uint8_t *buf = p_buffer; + int len = p_len; - const uint8_t * buf=p_buffer; - int len=p_len; + if (len < 4) { - if (len<4) { - - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); } + uint32_t type = decode_uint32(buf); - uint32_t type=decode_uint32(buf); - - ERR_FAIL_COND_V((type&ENCODE_MASK)>=Variant::VARIANT_MAX,ERR_INVALID_DATA); + ERR_FAIL_COND_V((type & ENCODE_MASK) >= Variant::VARIANT_MAX, ERR_INVALID_DATA); - buf+=4; - len-=4; + buf += 4; + len -= 4; if (r_len) - *r_len=4; + *r_len = 4; - switch(type&ENCODE_MASK) { + switch (type & ENCODE_MASK) { case Variant::NIL: { - r_variant=Variant(); + r_variant = Variant(); } break; case Variant::BOOL: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); bool val = decode_uint32(buf); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4; + (*r_len) += 4; } break; case Variant::INT: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); - if (type&ENCODE_FLAG_64) { + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); + if (type & ENCODE_FLAG_64) { int64_t val = decode_uint64(buf); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=8; + (*r_len) += 8; } else { int32_t val = decode_uint32(buf); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4; + (*r_len) += 4; } } break; case Variant::REAL: { - ERR_FAIL_COND_V(len<(int)4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4, ERR_INVALID_DATA); - if (type&ENCODE_FLAG_64) { + if (type & ENCODE_FLAG_64) { double val = decode_double(buf); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=8; + (*r_len) += 8; } else { float val = decode_float(buf); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4; + (*r_len) += 4; } } break; case Variant::STRING: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t strlen = decode_uint32(buf); - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)strlen>len,ERR_INVALID_DATA); + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)strlen > len, ERR_INVALID_DATA); String str; - str.parse_utf8((const char*)buf,strlen); - r_variant=str; + str.parse_utf8((const char *)buf, strlen); + r_variant = str; if (r_len) { - if (strlen%4) - (*r_len)+=4-strlen%4; - (*r_len)+=4+strlen; - + if (strlen % 4) + (*r_len) += 4 - strlen % 4; + (*r_len) += 4 + strlen; } } break; @@ -127,268 +124,262 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * case Variant::VECTOR2: { - ERR_FAIL_COND_V(len<(int)4*2,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 2, ERR_INVALID_DATA); Vector2 val; - val.x=decode_float(&buf[0]); - val.y=decode_float(&buf[4]); - r_variant=val; + val.x = decode_float(&buf[0]); + val.y = decode_float(&buf[4]); + r_variant = val; if (r_len) - (*r_len)+=4*2; + (*r_len) += 4 * 2; - } break; // 5 + } break; // 5 case Variant::RECT2: { - ERR_FAIL_COND_V(len<(int)4*4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA); Rect2 val; - val.pos.x=decode_float(&buf[0]); - val.pos.y=decode_float(&buf[4]); - val.size.x=decode_float(&buf[8]); - val.size.y=decode_float(&buf[12]); - r_variant=val; + val.pos.x = decode_float(&buf[0]); + val.pos.y = decode_float(&buf[4]); + val.size.x = decode_float(&buf[8]); + val.size.y = decode_float(&buf[12]); + r_variant = val; if (r_len) - (*r_len)+=4*4; + (*r_len) += 4 * 4; } break; case Variant::VECTOR3: { - ERR_FAIL_COND_V(len<(int)4*3,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 3, ERR_INVALID_DATA); Vector3 val; - val.x=decode_float(&buf[0]); - val.y=decode_float(&buf[4]); - val.z=decode_float(&buf[8]); - r_variant=val; + val.x = decode_float(&buf[0]); + val.y = decode_float(&buf[4]); + val.z = decode_float(&buf[8]); + r_variant = val; if (r_len) - (*r_len)+=4*3; + (*r_len) += 4 * 3; } break; case Variant::TRANSFORM2D: { - ERR_FAIL_COND_V(len<(int)4*6,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 6, ERR_INVALID_DATA); Transform2D val; - for(int i=0;i<3;i++) { - for(int j=0;j<2;j++) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 2; j++) { - val.elements[i][j]=decode_float(&buf[(i*2+j)*4]); + val.elements[i][j] = decode_float(&buf[(i * 2 + j) * 4]); } } - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4*6; + (*r_len) += 4 * 6; } break; case Variant::PLANE: { - ERR_FAIL_COND_V(len<(int)4*4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA); Plane val; - val.normal.x=decode_float(&buf[0]); - val.normal.y=decode_float(&buf[4]); - val.normal.z=decode_float(&buf[8]); - val.d=decode_float(&buf[12]); - r_variant=val; + val.normal.x = decode_float(&buf[0]); + val.normal.y = decode_float(&buf[4]); + val.normal.z = decode_float(&buf[8]); + val.d = decode_float(&buf[12]); + r_variant = val; if (r_len) - (*r_len)+=4*4; + (*r_len) += 4 * 4; } break; case Variant::QUAT: { - ERR_FAIL_COND_V(len<(int)4*4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA); Quat val; - val.x=decode_float(&buf[0]); - val.y=decode_float(&buf[4]); - val.z=decode_float(&buf[8]); - val.w=decode_float(&buf[12]); - r_variant=val; + val.x = decode_float(&buf[0]); + val.y = decode_float(&buf[4]); + val.z = decode_float(&buf[8]); + val.w = decode_float(&buf[12]); + r_variant = val; if (r_len) - (*r_len)+=4*4; + (*r_len) += 4 * 4; } break; case Variant::RECT3: { - ERR_FAIL_COND_V(len<(int)4*6,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 6, ERR_INVALID_DATA); Rect3 val; - val.pos.x=decode_float(&buf[0]); - val.pos.y=decode_float(&buf[4]); - val.pos.z=decode_float(&buf[8]); - val.size.x=decode_float(&buf[12]); - val.size.y=decode_float(&buf[16]); - val.size.z=decode_float(&buf[20]); - r_variant=val; + val.pos.x = decode_float(&buf[0]); + val.pos.y = decode_float(&buf[4]); + val.pos.z = decode_float(&buf[8]); + val.size.x = decode_float(&buf[12]); + val.size.y = decode_float(&buf[16]); + val.size.z = decode_float(&buf[20]); + r_variant = val; if (r_len) - (*r_len)+=4*6; + (*r_len) += 4 * 6; } break; case Variant::BASIS: { - ERR_FAIL_COND_V(len<(int)4*9,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 9, ERR_INVALID_DATA); Basis val; - for(int i=0;i<3;i++) { - for(int j=0;j<3;j++) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { - val.elements[i][j]=decode_float(&buf[(i*3+j)*4]); + val.elements[i][j] = decode_float(&buf[(i * 3 + j) * 4]); } } - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4*9; + (*r_len) += 4 * 9; } break; case Variant::TRANSFORM: { - ERR_FAIL_COND_V(len<(int)4*12,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 12, ERR_INVALID_DATA); Transform val; - for(int i=0;i<3;i++) { - for(int j=0;j<3;j++) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { - val.basis.elements[i][j]=decode_float(&buf[(i*3+j)*4]); + val.basis.elements[i][j] = decode_float(&buf[(i * 3 + j) * 4]); } } - val.origin[0]=decode_float(&buf[36]); - val.origin[1]=decode_float(&buf[40]); - val.origin[2]=decode_float(&buf[44]); + val.origin[0] = decode_float(&buf[36]); + val.origin[1] = decode_float(&buf[40]); + val.origin[2] = decode_float(&buf[44]); - r_variant=val; + r_variant = val; if (r_len) - (*r_len)+=4*12; + (*r_len) += 4 * 12; } break; // misc types case Variant::COLOR: { - ERR_FAIL_COND_V(len<(int)4*4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA); Color val; - val.r=decode_float(&buf[0]); - val.g=decode_float(&buf[4]); - val.b=decode_float(&buf[8]); - val.a=decode_float(&buf[12]); - r_variant=val; + val.r = decode_float(&buf[0]); + val.g = decode_float(&buf[4]); + val.b = decode_float(&buf[8]); + val.a = decode_float(&buf[12]); + r_variant = val; if (r_len) - (*r_len)+=4*4; + (*r_len) += 4 * 4; } break; case Variant::IMAGE: { - ERR_FAIL_COND_V(len<(int)5*4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < (int)5 * 4, ERR_INVALID_DATA); Image::Format fmt = (Image::Format)decode_uint32(&buf[0]); - ERR_FAIL_INDEX_V( fmt, Image::FORMAT_MAX, ERR_INVALID_DATA); + ERR_FAIL_INDEX_V(fmt, Image::FORMAT_MAX, ERR_INVALID_DATA); uint32_t mipmaps = decode_uint32(&buf[4]); uint32_t w = decode_uint32(&buf[8]); uint32_t h = decode_uint32(&buf[12]); uint32_t datalen = decode_uint32(&buf[16]); Image img; - if (datalen>0) { - len-=5*4; - ERR_FAIL_COND_V( len < datalen, ERR_INVALID_DATA ); + if (datalen > 0) { + len -= 5 * 4; + ERR_FAIL_COND_V(len < datalen, ERR_INVALID_DATA); PoolVector<uint8_t> data; data.resize(datalen); PoolVector<uint8_t>::Write wr = data.write(); - copymem(&wr[0],&buf[20],datalen); + copymem(&wr[0], &buf[20], datalen); wr = PoolVector<uint8_t>::Write(); - - - img=Image(w,h,mipmaps,fmt,data); + img = Image(w, h, mipmaps, fmt, data); } - r_variant=img; + r_variant = img; if (r_len) { - if (datalen%4) - (*r_len)+=4-datalen%4; + if (datalen % 4) + (*r_len) += 4 - datalen % 4; - (*r_len)+=4*5+datalen; + (*r_len) += 4 * 5 + datalen; } } break; case Variant::NODE_PATH: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t strlen = decode_uint32(buf); - if (strlen&0x80000000) { + if (strlen & 0x80000000) { //new format - ERR_FAIL_COND_V(len<12,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 12, ERR_INVALID_DATA); Vector<StringName> names; Vector<StringName> subnames; StringName prop; - uint32_t namecount=strlen&=0x7FFFFFFF; - uint32_t subnamecount = decode_uint32(buf+4); - uint32_t flags = decode_uint32(buf+8); + uint32_t namecount = strlen &= 0x7FFFFFFF; + uint32_t subnamecount = decode_uint32(buf + 4); + uint32_t flags = decode_uint32(buf + 8); - len-=12; - buf+=12; + len -= 12; + buf += 12; - int total=namecount+subnamecount; - if (flags&2) + int total = namecount + subnamecount; + if (flags & 2) total++; if (r_len) - (*r_len)+=12; - + (*r_len) += 12; - for(int i=0;i<total;i++) { + for (int i = 0; i < total; i++) { - ERR_FAIL_COND_V((int)len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V((int)len < 4, ERR_INVALID_DATA); strlen = decode_uint32(buf); - int pad=0; + int pad = 0; - if (strlen%4) - pad+=4-strlen%4; + if (strlen % 4) + pad += 4 - strlen % 4; - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)strlen+pad>len,ERR_INVALID_DATA); + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)strlen + pad > len, ERR_INVALID_DATA); String str; - str.parse_utf8((const char*)buf,strlen); - + str.parse_utf8((const char *)buf, strlen); - if (i<namecount) + if (i < namecount) names.push_back(str); - else if (i<namecount+subnamecount) + else if (i < namecount + subnamecount) subnames.push_back(str); else - prop=str; + prop = str; - buf+=strlen+pad; - len-=strlen+pad; + buf += strlen + pad; + len -= strlen + pad; if (r_len) - (*r_len)+=4+strlen+pad; - + (*r_len) += 4 + strlen + pad; } - r_variant=NodePath(names,subnames,flags&1,prop); + r_variant = NodePath(names, subnames, flags & 1, prop); } else { //old format, just a string - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)strlen>len,ERR_INVALID_DATA); - + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)strlen > len, ERR_INVALID_DATA); String str; - str.parse_utf8((const char*)buf,strlen); + str.parse_utf8((const char *)buf, strlen); - r_variant=NodePath(str); + r_variant = NodePath(str); if (r_len) - (*r_len)+=4+strlen; + (*r_len) += 4 + strlen; } } break; @@ -403,64 +394,62 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; case Variant::OBJECT: { - - r_variant = (Object*)NULL; + r_variant = (Object *)NULL; } break; case Variant::INPUT_EVENT: { InputEvent ie; - ie.type=decode_uint32(&buf[0]); - ie.device=decode_uint32(&buf[4]); + ie.type = decode_uint32(&buf[0]); + ie.device = decode_uint32(&buf[4]); if (r_len) - (*r_len)+=12; + (*r_len) += 12; - switch(ie.type) { + switch (ie.type) { case InputEvent::KEY: { - uint32_t mods=decode_uint32(&buf[12]); - if (mods&KEY_MASK_SHIFT) - ie.key.mod.shift=true; - if (mods&KEY_MASK_CTRL) - ie.key.mod.control=true; - if (mods&KEY_MASK_ALT) - ie.key.mod.alt=true; - if (mods&KEY_MASK_META) - ie.key.mod.meta=true; - ie.key.scancode=decode_uint32(&buf[16]); + uint32_t mods = decode_uint32(&buf[12]); + if (mods & KEY_MASK_SHIFT) + ie.key.mod.shift = true; + if (mods & KEY_MASK_CTRL) + ie.key.mod.control = true; + if (mods & KEY_MASK_ALT) + ie.key.mod.alt = true; + if (mods & KEY_MASK_META) + ie.key.mod.meta = true; + ie.key.scancode = decode_uint32(&buf[16]); if (r_len) - (*r_len)+=8; - + (*r_len) += 8; } break; case InputEvent::MOUSE_BUTTON: { - ie.mouse_button.button_index=decode_uint32(&buf[12]); + ie.mouse_button.button_index = decode_uint32(&buf[12]); if (r_len) - (*r_len)+=4; + (*r_len) += 4; } break; case InputEvent::JOYPAD_BUTTON: { - ie.joy_button.button_index=decode_uint32(&buf[12]); + ie.joy_button.button_index = decode_uint32(&buf[12]); if (r_len) - (*r_len)+=4; + (*r_len) += 4; } break; case InputEvent::SCREEN_TOUCH: { - ie.screen_touch.index=decode_uint32(&buf[12]); + ie.screen_touch.index = decode_uint32(&buf[12]); if (r_len) - (*r_len)+=4; + (*r_len) += 4; } break; case InputEvent::JOYPAD_MOTION: { - ie.joy_motion.axis=decode_uint32(&buf[12]); - ie.joy_motion.axis_value=decode_float(&buf[16]); + ie.joy_motion.axis = decode_uint32(&buf[12]); + ie.joy_motion.axis_value = decode_float(&buf[16]); if (r_len) - (*r_len)+=8; + (*r_len) += 8; } break; } @@ -469,125 +458,121 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * } break; case Variant::DICTIONARY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); - uint32_t count = decode_uint32(buf); - // bool shared = count&0x80000000; - count&=0x7FFFFFFF; + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); + uint32_t count = decode_uint32(buf); + // bool shared = count&0x80000000; + count &= 0x7FFFFFFF; - buf+=4; - len-=4; + buf += 4; + len -= 4; if (r_len) { - (*r_len)+=4; + (*r_len) += 4; } - Dictionary d; + Dictionary d; - for(uint32_t i=0;i<count;i++) { + for (uint32_t i = 0; i < count; i++) { - Variant key,value; + Variant key, value; int used; - Error err = decode_variant(key,buf,len,&used); - ERR_FAIL_COND_V(err,err); + Error err = decode_variant(key, buf, len, &used); + ERR_FAIL_COND_V(err, err); - buf+=used; - len-=used; + buf += used; + len -= used; if (r_len) { - (*r_len)+=used; + (*r_len) += used; } - err = decode_variant(value,buf,len,&used); - ERR_FAIL_COND_V(err,err); + err = decode_variant(value, buf, len, &used); + ERR_FAIL_COND_V(err, err); - buf+=used; - len-=used; + buf += used; + len -= used; if (r_len) { - (*r_len)+=used; + (*r_len) += used; } - d[key]=value; + d[key] = value; } - r_variant=d; + r_variant = d; } break; case Variant::ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - // bool shared = count&0x80000000; - count&=0x7FFFFFFF; + // bool shared = count&0x80000000; + count &= 0x7FFFFFFF; - buf+=4; - len-=4; + buf += 4; + len -= 4; if (r_len) { - (*r_len)+=4; + (*r_len) += 4; } - Array varr; + Array varr; - for(uint32_t i=0;i<count;i++) { + for (uint32_t i = 0; i < count; i++) { - int used=0; + int used = 0; Variant v; - Error err = decode_variant(v,buf,len,&used); - ERR_FAIL_COND_V(err,err); - buf+=used; - len-=used; + Error err = decode_variant(v, buf, len, &used); + ERR_FAIL_COND_V(err, err); + buf += used; + len -= used; varr.push_back(v); if (r_len) { - (*r_len)+=used; + (*r_len) += used; } } - r_variant=varr; - + r_variant = varr; } break; // arrays case Variant::POOL_BYTE_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)count>len,ERR_INVALID_DATA); - + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)count > len, ERR_INVALID_DATA); PoolVector<uint8_t> data; if (count) { data.resize(count); PoolVector<uint8_t>::Write w = data.write(); - for(int i=0;i<count;i++) { + for (int i = 0; i < count; i++) { - w[i]=buf[i]; + w[i] = buf[i]; } w = PoolVector<uint8_t>::Write(); } - r_variant=data; + r_variant = data; if (r_len) { - if (count%4) - (*r_len)+=4-count%4; - (*r_len)+=4+count; + if (count % 4) + (*r_len) += 4 - count % 4; + (*r_len) += 4 + count; } - - } break; case Variant::POOL_INT_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)count*4>len,ERR_INVALID_DATA); + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)count * 4 > len, ERR_INVALID_DATA); PoolVector<int> data; @@ -595,26 +580,26 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * //const int*rbuf=(const int*)buf; data.resize(count); PoolVector<int>::Write w = data.write(); - for(int i=0;i<count;i++) { + for (int i = 0; i < count; i++) { - w[i]=decode_uint32(&buf[i*4]); + w[i] = decode_uint32(&buf[i * 4]); } w = PoolVector<int>::Write(); } - r_variant=Variant(data); + r_variant = Variant(data); if (r_len) { - (*r_len)+=4+count*sizeof(int); + (*r_len) += 4 + count * sizeof(int); } } break; case Variant::POOL_REAL_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)count*4>len,ERR_INVALID_DATA); + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)count * 4 > len, ERR_INVALID_DATA); PoolVector<float> data; @@ -622,182 +607,173 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * //const float*rbuf=(const float*)buf; data.resize(count); PoolVector<float>::Write w = data.write(); - for(int i=0;i<count;i++) { + for (int i = 0; i < count; i++) { - w[i]=decode_float(&buf[i*4]); + w[i] = decode_float(&buf[i * 4]); } w = PoolVector<float>::Write(); } - r_variant=data; + r_variant = data; if (r_len) { - (*r_len)+=4+count*sizeof(float); + (*r_len) += 4 + count * sizeof(float); } - } break; case Variant::POOL_STRING_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); PoolVector<String> strings; - buf+=4; - len-=4; + buf += 4; + len -= 4; if (r_len) - (*r_len)+=4; + (*r_len) += 4; //printf("string count: %i\n",count); - for(int i=0;i<(int)count;i++) { + for (int i = 0; i < (int)count; i++) { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t strlen = decode_uint32(buf); - buf+=4; - len-=4; - ERR_FAIL_COND_V((int)strlen>len,ERR_INVALID_DATA); + buf += 4; + len -= 4; + ERR_FAIL_COND_V((int)strlen > len, ERR_INVALID_DATA); //printf("loaded string: %s\n",(const char*)buf); String str; - str.parse_utf8((const char*)buf,strlen); + str.parse_utf8((const char *)buf, strlen); strings.push_back(str); - buf+=strlen; - len-=strlen; + buf += strlen; + len -= strlen; if (r_len) - (*r_len)+=4+strlen; + (*r_len) += 4 + strlen; - if (strlen%4) { - int pad = 4-(strlen%4); - buf+=pad; - len-=pad; + if (strlen % 4) { + int pad = 4 - (strlen % 4); + buf += pad; + len -= pad; if (r_len) { - (*r_len)+=pad; + (*r_len) += pad; } } - } - r_variant=strings; - + r_variant = strings; } break; case Variant::POOL_VECTOR2_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; + buf += 4; + len -= 4; - ERR_FAIL_COND_V((int)count*4*2>len,ERR_INVALID_DATA); + ERR_FAIL_COND_V((int)count * 4 * 2 > len, ERR_INVALID_DATA); PoolVector<Vector2> varray; if (r_len) { - (*r_len)+=4; + (*r_len) += 4; } if (count) { varray.resize(count); PoolVector<Vector2>::Write w = varray.write(); - for(int i=0;i<(int)count;i++) { - - w[i].x=decode_float(buf+i*4*2+4*0); - w[i].y=decode_float(buf+i*4*2+4*1); + for (int i = 0; i < (int)count; i++) { + w[i].x = decode_float(buf + i * 4 * 2 + 4 * 0); + w[i].y = decode_float(buf + i * 4 * 2 + 4 * 1); } - int adv = 4*2*count; + int adv = 4 * 2 * count; if (r_len) - (*r_len)+=adv; - len-=adv; - buf+=adv; - + (*r_len) += adv; + len -= adv; + buf += adv; } - r_variant=varray; + r_variant = varray; } break; case Variant::POOL_VECTOR3_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; + buf += 4; + len -= 4; - ERR_FAIL_COND_V((int)count*4*3>len,ERR_INVALID_DATA); + ERR_FAIL_COND_V((int)count * 4 * 3 > len, ERR_INVALID_DATA); PoolVector<Vector3> varray; if (r_len) { - (*r_len)+=4; + (*r_len) += 4; } if (count) { varray.resize(count); PoolVector<Vector3>::Write w = varray.write(); - for(int i=0;i<(int)count;i++) { - - w[i].x=decode_float(buf+i*4*3+4*0); - w[i].y=decode_float(buf+i*4*3+4*1); - w[i].z=decode_float(buf+i*4*3+4*2); + for (int i = 0; i < (int)count; i++) { + w[i].x = decode_float(buf + i * 4 * 3 + 4 * 0); + w[i].y = decode_float(buf + i * 4 * 3 + 4 * 1); + w[i].z = decode_float(buf + i * 4 * 3 + 4 * 2); } - int adv = 4*3*count; + int adv = 4 * 3 * count; if (r_len) - (*r_len)+=adv; - len-=adv; - buf+=adv; - + (*r_len) += adv; + len -= adv; + buf += adv; } - r_variant=varray; + r_variant = varray; } break; case Variant::POOL_COLOR_ARRAY: { - ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA); + ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); uint32_t count = decode_uint32(buf); - buf+=4; - len-=4; + buf += 4; + len -= 4; - ERR_FAIL_COND_V((int)count*4*4>len,ERR_INVALID_DATA); + ERR_FAIL_COND_V((int)count * 4 * 4 > len, ERR_INVALID_DATA); PoolVector<Color> carray; if (r_len) { - (*r_len)+=4; + (*r_len) += 4; } if (count) { carray.resize(count); PoolVector<Color>::Write w = carray.write(); - for(int i=0;i<(int)count;i++) { - - w[i].r=decode_float(buf+i*4*4+4*0); - w[i].g=decode_float(buf+i*4*4+4*1); - w[i].b=decode_float(buf+i*4*4+4*2); - w[i].a=decode_float(buf+i*4*4+4*3); + for (int i = 0; i < (int)count; i++) { + w[i].r = decode_float(buf + i * 4 * 4 + 4 * 0); + w[i].g = decode_float(buf + i * 4 * 4 + 4 * 1); + w[i].b = decode_float(buf + i * 4 * 4 + 4 * 2); + w[i].a = decode_float(buf + i * 4 * 4 + 4 * 3); } - int adv = 4*4*count; + int adv = 4 * 4 * count; if (r_len) - (*r_len)+=adv; - len-=adv; - buf+=adv; - + (*r_len) += adv; + len -= adv; + buf += adv; } - r_variant=carray; + r_variant = carray; } break; default: { ERR_FAIL_V(ERR_BUG); } @@ -806,39 +782,39 @@ Error decode_variant(Variant& r_variant,const uint8_t *p_buffer, int p_len,int * return OK; } -Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { +Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) { - uint8_t * buf=r_buffer; + uint8_t *buf = r_buffer; - r_len=0; + r_len = 0; - uint32_t flags=0; + uint32_t flags = 0; - switch(p_variant.get_type()) { + switch (p_variant.get_type()) { case Variant::INT: { int64_t val = p_variant; - if (val>0x7FFFFFFF || val < -0x80000000) { - flags|=ENCODE_FLAG_64; + if (val > 0x7FFFFFFF || val < -0x80000000) { + flags |= ENCODE_FLAG_64; } } break; case Variant::REAL: { double d = p_variant; float f = d; - if (double(f)!=d) { - flags|=ENCODE_FLAG_64; //always encode real as double + if (double(f) != d) { + flags |= ENCODE_FLAG_64; //always encode real as double } } break; } if (buf) { - encode_uint32(p_variant.get_type()|flags,buf); - buf+=4; + encode_uint32(p_variant.get_type() | flags, buf); + buf += 4; } - r_len+=4; + r_len += 4; - switch(p_variant.get_type()) { + switch (p_variant.get_type()) { case Variant::NIL: { @@ -847,118 +823,115 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::BOOL: { if (buf) { - encode_uint32(p_variant.operator bool(),buf); + encode_uint32(p_variant.operator bool(), buf); } - r_len+=4; + r_len += 4; } break; case Variant::INT: { int64_t val = p_variant; - if (val>0x7FFFFFFF || val < -0x80000000) { + if (val > 0x7FFFFFFF || val < -0x80000000) { //64 bits if (buf) { - encode_uint64(val,buf); + encode_uint64(val, buf); } - r_len+=8; + r_len += 8; } else { if (buf) { - encode_uint32(int32_t(val),buf); + encode_uint32(int32_t(val), buf); } - r_len+=4; + r_len += 4; } } break; case Variant::REAL: { double d = p_variant; float f = d; - if (double(f)!=d) { + if (double(f) != d) { if (buf) { - encode_double(p_variant.operator double(),buf); + encode_double(p_variant.operator double(), buf); } - r_len+=8; + r_len += 8; } else { if (buf) { - encode_double(p_variant.operator float(),buf); + encode_double(p_variant.operator float(), buf); } - r_len+=4; + r_len += 4; } - } break; case Variant::NODE_PATH: { - NodePath np=p_variant; + NodePath np = p_variant; if (buf) { - encode_uint32(uint32_t(np.get_name_count())|0x80000000,buf); //for compatibility with the old format - encode_uint32(np.get_subname_count(),buf+4); - uint32_t flags=0; + encode_uint32(uint32_t(np.get_name_count()) | 0x80000000, buf); //for compatibility with the old format + encode_uint32(np.get_subname_count(), buf + 4); + uint32_t flags = 0; if (np.is_absolute()) - flags|=1; - if (np.get_property()!=StringName()) - flags|=2; + flags |= 1; + if (np.get_property() != StringName()) + flags |= 2; - encode_uint32(flags,buf+8); + encode_uint32(flags, buf + 8); - buf+=12; + buf += 12; } - r_len+=12; + r_len += 12; - int total = np.get_name_count()+np.get_subname_count(); - if (np.get_property()!=StringName()) + int total = np.get_name_count() + np.get_subname_count(); + if (np.get_property() != StringName()) total++; - for(int i=0;i<total;i++) { + for (int i = 0; i < total; i++) { String str; - if (i<np.get_name_count()) - str=np.get_name(i); - else if (i<np.get_name_count()+np.get_subname_count()) - str=np.get_subname(i-np.get_subname_count()); + if (i < np.get_name_count()) + str = np.get_name(i); + else if (i < np.get_name_count() + np.get_subname_count()) + str = np.get_subname(i - np.get_subname_count()); else - str=np.get_property(); + str = np.get_property(); CharString utf8 = str.utf8(); int pad = 0; - if (utf8.length()%4) - pad=4-utf8.length()%4; + if (utf8.length() % 4) + pad = 4 - utf8.length() % 4; if (buf) { - encode_uint32(utf8.length(),buf); - buf+=4; - copymem(buf,utf8.get_data(),utf8.length()); - buf+=pad+utf8.length(); + encode_uint32(utf8.length(), buf); + buf += 4; + copymem(buf, utf8.get_data(), utf8.length()); + buf += pad + utf8.length(); } - - r_len+=4+utf8.length()+pad; + r_len += 4 + utf8.length() + pad; } } break; case Variant::STRING: { - CharString utf8 = p_variant.operator String().utf8(); if (buf) { - encode_uint32(utf8.length(),buf); - buf+=4; - copymem(buf,utf8.get_data(),utf8.length()); + encode_uint32(utf8.length(), buf); + buf += 4; + copymem(buf, utf8.get_data(), utf8.length()); } - r_len+=4+utf8.length(); - while (r_len%4) + r_len += 4 + utf8.length(); + while (r_len % 4) r_len++; //pad } break; @@ -967,132 +940,126 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::VECTOR2: { if (buf) { - Vector2 v2=p_variant; - encode_float(v2.x,&buf[0]); - encode_float(v2.y,&buf[4]); - + Vector2 v2 = p_variant; + encode_float(v2.x, &buf[0]); + encode_float(v2.y, &buf[4]); } - r_len+=2*4; + r_len += 2 * 4; - } break; // 5 + } break; // 5 case Variant::RECT2: { if (buf) { - Rect2 r2=p_variant; - encode_float(r2.pos.x,&buf[0]); - encode_float(r2.pos.y,&buf[4]); - encode_float(r2.size.x,&buf[8]); - encode_float(r2.size.y,&buf[12]); + Rect2 r2 = p_variant; + encode_float(r2.pos.x, &buf[0]); + encode_float(r2.pos.y, &buf[4]); + encode_float(r2.size.x, &buf[8]); + encode_float(r2.size.y, &buf[12]); } - r_len+=4*4; + r_len += 4 * 4; } break; case Variant::VECTOR3: { if (buf) { - Vector3 v3=p_variant; - encode_float(v3.x,&buf[0]); - encode_float(v3.y,&buf[4]); - encode_float(v3.z,&buf[8]); + Vector3 v3 = p_variant; + encode_float(v3.x, &buf[0]); + encode_float(v3.y, &buf[4]); + encode_float(v3.z, &buf[8]); } - r_len+=3*4; + r_len += 3 * 4; } break; case Variant::TRANSFORM2D: { if (buf) { - Transform2D val=p_variant; - for(int i=0;i<3;i++) { - for(int j=0;j<2;j++) { + Transform2D val = p_variant; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 2; j++) { - copymem(&buf[(i*2+j)*4],&val.elements[i][j],sizeof(float)); + copymem(&buf[(i * 2 + j) * 4], &val.elements[i][j], sizeof(float)); } } } - - r_len+=6*4; + r_len += 6 * 4; } break; case Variant::PLANE: { if (buf) { - Plane p=p_variant; - encode_float(p.normal.x,&buf[0]); - encode_float(p.normal.y,&buf[4]); - encode_float(p.normal.z,&buf[8]); - encode_float(p.d,&buf[12]); + Plane p = p_variant; + encode_float(p.normal.x, &buf[0]); + encode_float(p.normal.y, &buf[4]); + encode_float(p.normal.z, &buf[8]); + encode_float(p.d, &buf[12]); } - r_len+=4*4; + r_len += 4 * 4; } break; case Variant::QUAT: { if (buf) { - Quat q=p_variant; - encode_float(q.x,&buf[0]); - encode_float(q.y,&buf[4]); - encode_float(q.z,&buf[8]); - encode_float(q.w,&buf[12]); + Quat q = p_variant; + encode_float(q.x, &buf[0]); + encode_float(q.y, &buf[4]); + encode_float(q.z, &buf[8]); + encode_float(q.w, &buf[12]); } - r_len+=4*4; + r_len += 4 * 4; } break; case Variant::RECT3: { if (buf) { - Rect3 aabb=p_variant; - encode_float(aabb.pos.x,&buf[0]); - encode_float(aabb.pos.y,&buf[4]); - encode_float(aabb.pos.z,&buf[8]); - encode_float(aabb.size.x,&buf[12]); - encode_float(aabb.size.y,&buf[16]); - encode_float(aabb.size.z,&buf[20]); + Rect3 aabb = p_variant; + encode_float(aabb.pos.x, &buf[0]); + encode_float(aabb.pos.y, &buf[4]); + encode_float(aabb.pos.z, &buf[8]); + encode_float(aabb.size.x, &buf[12]); + encode_float(aabb.size.y, &buf[16]); + encode_float(aabb.size.z, &buf[20]); } - r_len+=6*4; - + r_len += 6 * 4; } break; case Variant::BASIS: { if (buf) { - Basis val=p_variant; - for(int i=0;i<3;i++) { - for(int j=0;j<3;j++) { + Basis val = p_variant; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { - copymem(&buf[(i*3+j)*4],&val.elements[i][j],sizeof(float)); + copymem(&buf[(i * 3 + j) * 4], &val.elements[i][j], sizeof(float)); } } } - - r_len+=9*4; + r_len += 9 * 4; } break; case Variant::TRANSFORM: { if (buf) { - Transform val=p_variant; - for(int i=0;i<3;i++) { - for(int j=0;j<3;j++) { + Transform val = p_variant; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { - copymem(&buf[(i*3+j)*4],&val.basis.elements[i][j],sizeof(float)); + copymem(&buf[(i * 3 + j) * 4], &val.basis.elements[i][j], sizeof(float)); } } - encode_float(val.origin.x,&buf[36]); - encode_float(val.origin.y,&buf[40]); - encode_float(val.origin.z,&buf[44]); - - + encode_float(val.origin.x, &buf[36]); + encode_float(val.origin.y, &buf[40]); + encode_float(val.origin.z, &buf[44]); } - r_len+=12*4; + r_len += 12 * 4; } break; @@ -1100,38 +1067,38 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::COLOR: { if (buf) { - Color c=p_variant; - encode_float(c.r,&buf[0]); - encode_float(c.g,&buf[4]); - encode_float(c.b,&buf[8]); - encode_float(c.a,&buf[12]); + Color c = p_variant; + encode_float(c.r, &buf[0]); + encode_float(c.g, &buf[4]); + encode_float(c.b, &buf[8]); + encode_float(c.a, &buf[12]); } - r_len+=4*4; + r_len += 4 * 4; } break; case Variant::IMAGE: { Image image = p_variant; - PoolVector<uint8_t> data=image.get_data(); + PoolVector<uint8_t> data = image.get_data(); if (buf) { - encode_uint32(image.get_format(),&buf[0]); - encode_uint32(image.has_mipmaps(),&buf[4]); - encode_uint32(image.get_width(),&buf[8]); - encode_uint32(image.get_height(),&buf[12]); - int ds=data.size(); - encode_uint32(ds,&buf[16]); + encode_uint32(image.get_format(), &buf[0]); + encode_uint32(image.has_mipmaps(), &buf[4]); + encode_uint32(image.get_width(), &buf[8]); + encode_uint32(image.get_height(), &buf[12]); + int ds = data.size(); + encode_uint32(ds, &buf[16]); PoolVector<uint8_t>::Read r = data.read(); - copymem(&buf[20],&r[0],ds); + copymem(&buf[20], &r[0], ds); } - int pad=0; - if (data.size()%4) - pad=4-data.size()%4; + int pad = 0; + if (data.size() % 4) + pad = 4 - data.size() % 4; - r_len+=data.size()+5*4+pad; + r_len += data.size() + 5 * 4 + pad; } break; /*case Variant::RESOURCE: { @@ -1142,84 +1109,81 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::_RID: case Variant::OBJECT: { - } break; case Variant::INPUT_EVENT: { - - InputEvent ie=p_variant; + InputEvent ie = p_variant; if (buf) { - encode_uint32(ie.type,&buf[0]); - encode_uint32(ie.device,&buf[4]); - encode_uint32(0,&buf[8]); + encode_uint32(ie.type, &buf[0]); + encode_uint32(ie.device, &buf[4]); + encode_uint32(0, &buf[8]); } - int llen=12; + int llen = 12; - switch(ie.type) { + switch (ie.type) { case InputEvent::KEY: { if (buf) { - uint32_t mods=0; + uint32_t mods = 0; if (ie.key.mod.shift) - mods|=KEY_MASK_SHIFT; + mods |= KEY_MASK_SHIFT; if (ie.key.mod.control) - mods|=KEY_MASK_CTRL; + mods |= KEY_MASK_CTRL; if (ie.key.mod.alt) - mods|=KEY_MASK_ALT; + mods |= KEY_MASK_ALT; if (ie.key.mod.meta) - mods|=KEY_MASK_META; + mods |= KEY_MASK_META; - encode_uint32(mods,&buf[llen]); - encode_uint32(ie.key.scancode,&buf[llen+4]); + encode_uint32(mods, &buf[llen]); + encode_uint32(ie.key.scancode, &buf[llen + 4]); } - llen+=8; + llen += 8; } break; case InputEvent::MOUSE_BUTTON: { if (buf) { - encode_uint32(ie.mouse_button.button_index,&buf[llen]); + encode_uint32(ie.mouse_button.button_index, &buf[llen]); } - llen+=4; + llen += 4; } break; case InputEvent::JOYPAD_BUTTON: { if (buf) { - encode_uint32(ie.joy_button.button_index,&buf[llen]); + encode_uint32(ie.joy_button.button_index, &buf[llen]); } - llen+=4; + llen += 4; } break; case InputEvent::SCREEN_TOUCH: { if (buf) { - encode_uint32(ie.screen_touch.index,&buf[llen]); + encode_uint32(ie.screen_touch.index, &buf[llen]); } - llen+=4; + llen += 4; } break; case InputEvent::JOYPAD_MOTION: { if (buf) { int axis = ie.joy_motion.axis; - encode_uint32(axis,&buf[llen]); - encode_float(ie.joy_motion.axis_value, &buf[llen+4]); + encode_uint32(axis, &buf[llen]); + encode_float(ie.joy_motion.axis_value, &buf[llen + 4]); } - llen+=8; + llen += 8; } break; } if (buf) - encode_uint32(llen,&buf[8]); - r_len+=llen; - + encode_uint32(llen, &buf[8]); + r_len += llen; // not supported } break; @@ -1228,16 +1192,15 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { Dictionary d = p_variant; if (buf) { - encode_uint32(uint32_t(d.size()),buf); - buf+=4; + encode_uint32(uint32_t(d.size()), buf); + buf += 4; } - r_len+=4; + r_len += 4; List<Variant> keys; d.get_key_list(&keys); - - for(List<Variant>::Element *E=keys.front();E;E=E->next()) { + for (List<Variant>::Element *E = keys.front(); E; E = E->next()) { /* CharString utf8 = E->->utf8(); @@ -1253,14 +1216,14 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { r_len++; //pad */ int len; - encode_variant(E->get(),buf,len); - ERR_FAIL_COND_V(len%4,ERR_BUG); - r_len+=len; + encode_variant(E->get(), buf, len); + ERR_FAIL_COND_V(len % 4, ERR_BUG); + r_len += len; if (buf) buf += len; - encode_variant(d[E->get()],buf,len); - ERR_FAIL_COND_V(len%4,ERR_BUG); - r_len+=len; + encode_variant(d[E->get()], buf, len); + ERR_FAIL_COND_V(len % 4, ERR_BUG); + r_len += len; if (buf) buf += len; } @@ -1271,107 +1234,101 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { Array v = p_variant; if (buf) { - encode_uint32(uint32_t(v.size()),buf); - buf+=4; + encode_uint32(uint32_t(v.size()), buf); + buf += 4; } - r_len+=4; + r_len += 4; - for(int i=0;i<v.size();i++) { + for (int i = 0; i < v.size(); i++) { int len; - encode_variant(v.get(i),buf,len); - ERR_FAIL_COND_V(len%4,ERR_BUG); - r_len+=len; + encode_variant(v.get(i), buf, len); + ERR_FAIL_COND_V(len % 4, ERR_BUG); + r_len += len; if (buf) - buf+=len; + buf += len; } - } break; // arrays case Variant::POOL_BYTE_ARRAY: { PoolVector<uint8_t> data = p_variant; - int datalen=data.size(); - int datasize=sizeof(uint8_t); + int datalen = data.size(); + int datasize = sizeof(uint8_t); if (buf) { - encode_uint32(datalen,buf); - buf+=4; + encode_uint32(datalen, buf); + buf += 4; PoolVector<uint8_t>::Read r = data.read(); - copymem(buf,&r[0],datalen*datasize); - + copymem(buf, &r[0], datalen * datasize); } - r_len+=4+datalen*datasize; - while(r_len%4) + r_len += 4 + datalen * datasize; + while (r_len % 4) r_len++; } break; case Variant::POOL_INT_ARRAY: { PoolVector<int> data = p_variant; - int datalen=data.size(); - int datasize=sizeof(int32_t); + int datalen = data.size(); + int datasize = sizeof(int32_t); if (buf) { - encode_uint32(datalen,buf); - buf+=4; + encode_uint32(datalen, buf); + buf += 4; PoolVector<int>::Read r = data.read(); - for(int i=0;i<datalen;i++) - encode_uint32(r[i],&buf[i*datasize]); - + for (int i = 0; i < datalen; i++) + encode_uint32(r[i], &buf[i * datasize]); } - r_len+=4+datalen*datasize; + r_len += 4 + datalen * datasize; } break; case Variant::POOL_REAL_ARRAY: { PoolVector<real_t> data = p_variant; - int datalen=data.size(); - int datasize=sizeof(real_t); + int datalen = data.size(); + int datasize = sizeof(real_t); if (buf) { - encode_uint32(datalen,buf); - buf+=4; + encode_uint32(datalen, buf); + buf += 4; PoolVector<real_t>::Read r = data.read(); - for(int i=0;i<datalen;i++) - encode_float(r[i],&buf[i*datasize]); - + for (int i = 0; i < datalen; i++) + encode_float(r[i], &buf[i * datasize]); } - r_len+=4+datalen*datasize; + r_len += 4 + datalen * datasize; } break; case Variant::POOL_STRING_ARRAY: { - PoolVector<String> data = p_variant; - int len=data.size(); + int len = data.size(); if (buf) { - encode_uint32(len,buf); - buf+=4; + encode_uint32(len, buf); + buf += 4; } - r_len+=4; - - for(int i=0;i<len;i++) { + r_len += 4; + for (int i = 0; i < len; i++) { CharString utf8 = data.get(i).utf8(); if (buf) { - encode_uint32(utf8.length()+1,buf); - buf+=4; - copymem(buf,utf8.get_data(),utf8.length()+1); - buf+=utf8.length()+1; + encode_uint32(utf8.length() + 1, buf); + buf += 4; + copymem(buf, utf8.get_data(), utf8.length() + 1); + buf += utf8.length() + 1; } - r_len+=4+utf8.length()+1; - while (r_len%4) { + r_len += 4 + utf8.length() + 1; + while (r_len % 4) { r_len++; //pad if (buf) buf++; @@ -1382,95 +1339,89 @@ Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) { case Variant::POOL_VECTOR2_ARRAY: { PoolVector<Vector2> data = p_variant; - int len=data.size(); + int len = data.size(); if (buf) { - encode_uint32(len,buf); - buf+=4; + encode_uint32(len, buf); + buf += 4; } - r_len+=4; + r_len += 4; if (buf) { - for(int i=0;i<len;i++) { + for (int i = 0; i < len; i++) { Vector2 v = data.get(i); - encode_float(v.x,&buf[0]); - encode_float(v.y,&buf[4]); - buf+=4*2; - + encode_float(v.x, &buf[0]); + encode_float(v.y, &buf[4]); + buf += 4 * 2; } } - r_len+=4*2*len; + r_len += 4 * 2 * len; } break; case Variant::POOL_VECTOR3_ARRAY: { PoolVector<Vector3> data = p_variant; - int len=data.size(); + int len = data.size(); if (buf) { - encode_uint32(len,buf); - buf+=4; + encode_uint32(len, buf); + buf += 4; } - r_len+=4; + r_len += 4; if (buf) { - for(int i=0;i<len;i++) { + for (int i = 0; i < len; i++) { Vector3 v = data.get(i); - encode_float(v.x,&buf[0]); - encode_float(v.y,&buf[4]); - encode_float(v.z,&buf[8]); - buf+=4*3; - + encode_float(v.x, &buf[0]); + encode_float(v.y, &buf[4]); + encode_float(v.z, &buf[8]); + buf += 4 * 3; } } - r_len+=4*3*len; + r_len += 4 * 3 * len; } break; case Variant::POOL_COLOR_ARRAY: { PoolVector<Color> data = p_variant; - int len=data.size(); + int len = data.size(); if (buf) { - encode_uint32(len,buf); - buf+=4; + encode_uint32(len, buf); + buf += 4; } - r_len+=4; + r_len += 4; if (buf) { - for(int i=0;i<len;i++) { + for (int i = 0; i < len; i++) { Color c = data.get(i); - - encode_float(c.r,&buf[0]); - encode_float(c.g,&buf[4]); - encode_float(c.b,&buf[8]); - encode_float(c.a,&buf[12]); - buf+=4*4; + encode_float(c.r, &buf[0]); + encode_float(c.g, &buf[4]); + encode_float(c.b, &buf[8]); + encode_float(c.a, &buf[12]); + buf += 4 * 4; } } - r_len+=4*4*len; + r_len += 4 * 4 * len; } break; default: { ERR_FAIL_V(ERR_BUG); } } return OK; - } - - |