1477 lines
27 KiB
C++
1477 lines
27 KiB
C++
/*************************************************************************/
|
|
/* marshalls.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
#include "marshalls.h"
|
|
#include "print_string.h"
|
|
#include "os/keyboard.h"
|
|
#include <stdio.h>
|
|
|
|
|
|
#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) {
|
|
|
|
const uint8_t * buf=p_buffer;
|
|
int len=p_len;
|
|
|
|
if (len<4) {
|
|
|
|
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
|
|
}
|
|
|
|
|
|
uint32_t type=decode_uint32(buf);
|
|
|
|
ERR_FAIL_COND_V((type&ENCODE_MASK)>=Variant::VARIANT_MAX,ERR_INVALID_DATA);
|
|
|
|
buf+=4;
|
|
len-=4;
|
|
if (r_len)
|
|
*r_len=4;
|
|
|
|
switch(type&ENCODE_MASK) {
|
|
|
|
case Variant::NIL: {
|
|
|
|
r_variant=Variant();
|
|
} break;
|
|
case Variant::BOOL: {
|
|
|
|
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
|
|
bool val = decode_uint32(buf);
|
|
r_variant=val;
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
} break;
|
|
case Variant::INT: {
|
|
|
|
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
|
|
if (type&ENCODE_FLAG_64) {
|
|
int64_t val = decode_uint64(buf);
|
|
r_variant=val;
|
|
if (r_len)
|
|
(*r_len)+=8;
|
|
|
|
} else {
|
|
int32_t val = decode_uint32(buf);
|
|
r_variant=val;
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
}
|
|
|
|
} break;
|
|
case Variant::REAL: {
|
|
|
|
ERR_FAIL_COND_V(len<(int)4,ERR_INVALID_DATA);
|
|
|
|
if (type&ENCODE_FLAG_64) {
|
|
double val = decode_double(buf);
|
|
r_variant=val;
|
|
if (r_len)
|
|
(*r_len)+=8;
|
|
} else {
|
|
float val = decode_float(buf);
|
|
r_variant=val;
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
}
|
|
|
|
} break;
|
|
case Variant::STRING: {
|
|
|
|
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);
|
|
|
|
String 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;
|
|
|
|
}
|
|
|
|
} break;
|
|
// math types
|
|
|
|
case Variant::VECTOR2: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*2;
|
|
|
|
} break; // 5
|
|
case Variant::RECT2: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*4;
|
|
|
|
} break;
|
|
case Variant::VECTOR3: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*3;
|
|
|
|
} break;
|
|
case Variant::TRANSFORM2D: {
|
|
|
|
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++) {
|
|
|
|
val.elements[i][j]=decode_float(&buf[(i*2+j)*4]);
|
|
}
|
|
}
|
|
|
|
r_variant=val;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*6;
|
|
|
|
} break;
|
|
case Variant::PLANE: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*4;
|
|
|
|
} break;
|
|
case Variant::QUAT: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*4;
|
|
|
|
} break;
|
|
case Variant::RECT3: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*6;
|
|
|
|
} break;
|
|
case Variant::BASIS: {
|
|
|
|
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++) {
|
|
|
|
val.elements[i][j]=decode_float(&buf[(i*3+j)*4]);
|
|
}
|
|
}
|
|
|
|
r_variant=val;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*9;
|
|
|
|
} break;
|
|
case Variant::TRANSFORM: {
|
|
|
|
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++) {
|
|
|
|
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]);
|
|
|
|
r_variant=val;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*12;
|
|
|
|
} break;
|
|
|
|
// misc types
|
|
case Variant::COLOR: {
|
|
|
|
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;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4*4;
|
|
|
|
} break;
|
|
case Variant::IMAGE: {
|
|
|
|
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);
|
|
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 );
|
|
PoolVector<uint8_t> data;
|
|
data.resize(datalen);
|
|
PoolVector<uint8_t>::Write wr = data.write();
|
|
copymem(&wr[0],&buf[20],datalen);
|
|
wr = PoolVector<uint8_t>::Write();
|
|
|
|
|
|
|
|
img=Image(w,h,mipmaps,fmt,data);
|
|
}
|
|
|
|
r_variant=img;
|
|
if (r_len) {
|
|
if (datalen%4)
|
|
(*r_len)+=4-datalen%4;
|
|
|
|
(*r_len)+=4*5+datalen;
|
|
}
|
|
|
|
} break;
|
|
case Variant::NODE_PATH: {
|
|
|
|
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
|
|
uint32_t strlen = decode_uint32(buf);
|
|
|
|
if (strlen&0x80000000) {
|
|
//new format
|
|
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);
|
|
|
|
len-=12;
|
|
buf+=12;
|
|
|
|
int total=namecount+subnamecount;
|
|
if (flags&2)
|
|
total++;
|
|
|
|
if (r_len)
|
|
(*r_len)+=12;
|
|
|
|
|
|
for(int i=0;i<total;i++) {
|
|
|
|
ERR_FAIL_COND_V((int)len<4,ERR_INVALID_DATA);
|
|
strlen = decode_uint32(buf);
|
|
|
|
int pad=0;
|
|
|
|
if (strlen%4)
|
|
pad+=4-strlen%4;
|
|
|
|
buf+=4;
|
|
len-=4;
|
|
ERR_FAIL_COND_V((int)strlen+pad>len,ERR_INVALID_DATA);
|
|
|
|
String str;
|
|
str.parse_utf8((const char*)buf,strlen);
|
|
|
|
|
|
if (i<namecount)
|
|
names.push_back(str);
|
|
else if (i<namecount+subnamecount)
|
|
subnames.push_back(str);
|
|
else
|
|
prop=str;
|
|
|
|
buf+=strlen+pad;
|
|
len-=strlen+pad;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4+strlen+pad;
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
String str;
|
|
str.parse_utf8((const char*)buf,strlen);
|
|
|
|
r_variant=NodePath(str);
|
|
|
|
if (r_len)
|
|
(*r_len)+=4+strlen;
|
|
}
|
|
|
|
} break;
|
|
/*case Variant::RESOURCE: {
|
|
|
|
ERR_EXPLAIN("Can't marshallize resources");
|
|
ERR_FAIL_V(ERR_INVALID_DATA); //no, i'm sorry, no go
|
|
} break;*/
|
|
case Variant::_RID: {
|
|
|
|
r_variant = RID();
|
|
} break;
|
|
case Variant::OBJECT: {
|
|
|
|
|
|
r_variant = (Object*)NULL;
|
|
} break;
|
|
case Variant::INPUT_EVENT: {
|
|
|
|
InputEvent ie;
|
|
|
|
ie.type=decode_uint32(&buf[0]);
|
|
ie.device=decode_uint32(&buf[4]);
|
|
|
|
if (r_len)
|
|
(*r_len)+=12;
|
|
|
|
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]);
|
|
|
|
if (r_len)
|
|
(*r_len)+=8;
|
|
|
|
|
|
} break;
|
|
case InputEvent::MOUSE_BUTTON: {
|
|
|
|
ie.mouse_button.button_index=decode_uint32(&buf[12]);
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
|
|
} break;
|
|
case InputEvent::JOYPAD_BUTTON: {
|
|
|
|
ie.joy_button.button_index=decode_uint32(&buf[12]);
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
} break;
|
|
case InputEvent::SCREEN_TOUCH: {
|
|
|
|
ie.screen_touch.index=decode_uint32(&buf[12]);
|
|
if (r_len)
|
|
(*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]);
|
|
if (r_len)
|
|
(*r_len)+=8;
|
|
} break;
|
|
}
|
|
|
|
r_variant = ie;
|
|
|
|
} 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;
|
|
|
|
buf+=4;
|
|
len-=4;
|
|
|
|
if (r_len) {
|
|
(*r_len)+=4;
|
|
}
|
|
|
|
Dictionary d;
|
|
|
|
for(uint32_t i=0;i<count;i++) {
|
|
|
|
Variant key,value;
|
|
|
|
int used;
|
|
Error err = decode_variant(key,buf,len,&used);
|
|
ERR_FAIL_COND_V(err,err);
|
|
|
|
buf+=used;
|
|
len-=used;
|
|
if (r_len) {
|
|
(*r_len)+=used;
|
|
}
|
|
|
|
err = decode_variant(value,buf,len,&used);
|
|
ERR_FAIL_COND_V(err,err);
|
|
|
|
buf+=used;
|
|
len-=used;
|
|
if (r_len) {
|
|
(*r_len)+=used;
|
|
}
|
|
|
|
d[key]=value;
|
|
}
|
|
|
|
r_variant=d;
|
|
|
|
} break;
|
|
case Variant::ARRAY: {
|
|
|
|
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;
|
|
|
|
if (r_len) {
|
|
(*r_len)+=4;
|
|
}
|
|
|
|
Array varr;
|
|
|
|
for(uint32_t i=0;i<count;i++) {
|
|
|
|
int used=0;
|
|
Variant v;
|
|
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_variant=varr;
|
|
|
|
|
|
} break;
|
|
|
|
// arrays
|
|
case Variant::POOL_BYTE_ARRAY: {
|
|
|
|
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);
|
|
|
|
|
|
PoolVector<uint8_t> data;
|
|
|
|
if (count) {
|
|
data.resize(count);
|
|
PoolVector<uint8_t>::Write w = data.write();
|
|
for(int i=0;i<count;i++) {
|
|
|
|
w[i]=buf[i];
|
|
}
|
|
|
|
w = PoolVector<uint8_t>::Write();
|
|
}
|
|
|
|
r_variant=data;
|
|
|
|
if (r_len) {
|
|
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);
|
|
uint32_t count = decode_uint32(buf);
|
|
buf+=4;
|
|
len-=4;
|
|
ERR_FAIL_COND_V((int)count*4>len,ERR_INVALID_DATA);
|
|
|
|
PoolVector<int> data;
|
|
|
|
if (count) {
|
|
//const int*rbuf=(const int*)buf;
|
|
data.resize(count);
|
|
PoolVector<int>::Write w = data.write();
|
|
for(int i=0;i<count;i++) {
|
|
|
|
w[i]=decode_uint32(&buf[i*4]);
|
|
}
|
|
|
|
w = PoolVector<int>::Write();
|
|
}
|
|
r_variant=Variant(data);
|
|
if (r_len) {
|
|
(*r_len)+=4+count*sizeof(int);
|
|
}
|
|
|
|
} break;
|
|
case Variant::POOL_REAL_ARRAY: {
|
|
|
|
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);
|
|
|
|
PoolVector<float> data;
|
|
|
|
if (count) {
|
|
//const float*rbuf=(const float*)buf;
|
|
data.resize(count);
|
|
PoolVector<float>::Write w = data.write();
|
|
for(int i=0;i<count;i++) {
|
|
|
|
w[i]=decode_float(&buf[i*4]);
|
|
}
|
|
|
|
w = PoolVector<float>::Write();
|
|
}
|
|
r_variant=data;
|
|
|
|
if (r_len) {
|
|
(*r_len)+=4+count*sizeof(float);
|
|
}
|
|
|
|
|
|
} break;
|
|
case Variant::POOL_STRING_ARRAY: {
|
|
|
|
ERR_FAIL_COND_V(len<4,ERR_INVALID_DATA);
|
|
uint32_t count = decode_uint32(buf);
|
|
|
|
PoolVector<String> strings;
|
|
buf+=4;
|
|
len-=4;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4;
|
|
//printf("string count: %i\n",count);
|
|
|
|
for(int i=0;i<(int)count;i++) {
|
|
|
|
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);
|
|
|
|
//printf("loaded string: %s\n",(const char*)buf);
|
|
String str;
|
|
str.parse_utf8((const char*)buf,strlen);
|
|
|
|
strings.push_back(str);
|
|
|
|
buf+=strlen;
|
|
len-=strlen;
|
|
|
|
if (r_len)
|
|
(*r_len)+=4+strlen;
|
|
|
|
if (strlen%4) {
|
|
int pad = 4-(strlen%4);
|
|
buf+=pad;
|
|
len-=pad;
|
|
if (r_len) {
|
|
(*r_len)+=pad;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
r_variant=strings;
|
|
|
|
|
|
} break;
|
|
case Variant::POOL_VECTOR2_ARRAY: {
|
|
|
|
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*2>len,ERR_INVALID_DATA);
|
|
PoolVector<Vector2> varray;
|
|
|
|
if (r_len) {
|
|
(*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);
|
|
|
|
}
|
|
|
|
int adv = 4*2*count;
|
|
|
|
if (r_len)
|
|
(*r_len)+=adv;
|
|
len-=adv;
|
|
buf+=adv;
|
|
|
|
}
|
|
|
|
r_variant=varray;
|
|
|
|
} break;
|
|
case Variant::POOL_VECTOR3_ARRAY: {
|
|
|
|
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*3>len,ERR_INVALID_DATA);
|
|
PoolVector<Vector3> varray;
|
|
|
|
if (r_len) {
|
|
(*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);
|
|
|
|
}
|
|
|
|
int adv = 4*3*count;
|
|
|
|
if (r_len)
|
|
(*r_len)+=adv;
|
|
len-=adv;
|
|
buf+=adv;
|
|
|
|
}
|
|
|
|
r_variant=varray;
|
|
|
|
} break;
|
|
case Variant::POOL_COLOR_ARRAY: {
|
|
|
|
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*4>len,ERR_INVALID_DATA);
|
|
PoolVector<Color> carray;
|
|
|
|
if (r_len) {
|
|
(*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);
|
|
|
|
}
|
|
|
|
int adv = 4*4*count;
|
|
|
|
if (r_len)
|
|
(*r_len)+=adv;
|
|
len-=adv;
|
|
buf+=adv;
|
|
|
|
}
|
|
|
|
r_variant=carray;
|
|
|
|
} break;
|
|
default: { ERR_FAIL_V(ERR_BUG); }
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error encode_variant(const Variant& p_variant, uint8_t *r_buffer, int &r_len) {
|
|
|
|
uint8_t * buf=r_buffer;
|
|
|
|
r_len=0;
|
|
|
|
uint32_t flags=0;
|
|
|
|
switch(p_variant.get_type()) {
|
|
|
|
case Variant::INT: {
|
|
int64_t val = p_variant;
|
|
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
|
|
}
|
|
} break;
|
|
}
|
|
|
|
if (buf) {
|
|
encode_uint32(p_variant.get_type()|flags,buf);
|
|
buf+=4;
|
|
}
|
|
r_len+=4;
|
|
|
|
switch(p_variant.get_type()) {
|
|
|
|
case Variant::NIL: {
|
|
|
|
//nothing to do
|
|
} break;
|
|
case Variant::BOOL: {
|
|
|
|
if (buf) {
|
|
encode_uint32(p_variant.operator bool(),buf);
|
|
}
|
|
|
|
r_len+=4;
|
|
|
|
} break;
|
|
case Variant::INT: {
|
|
|
|
int64_t val = p_variant;
|
|
if (val>0x7FFFFFFF || val < -0x80000000) {
|
|
//64 bits
|
|
if (buf) {
|
|
encode_uint64(val,buf);
|
|
}
|
|
|
|
r_len+=8;
|
|
} else {
|
|
if (buf) {
|
|
encode_uint32(int32_t(val),buf);
|
|
}
|
|
|
|
r_len+=4;
|
|
}
|
|
} break;
|
|
case Variant::REAL: {
|
|
|
|
double d = p_variant;
|
|
float f = d;
|
|
if (double(f)!=d) {
|
|
if (buf) {
|
|
encode_double(p_variant.operator double(),buf);
|
|
}
|
|
|
|
r_len+=8;
|
|
|
|
} else {
|
|
|
|
if (buf) {
|
|
encode_double(p_variant.operator float(),buf);
|
|
}
|
|
|
|
r_len+=4;
|
|
}
|
|
|
|
|
|
} break;
|
|
case Variant::NODE_PATH: {
|
|
|
|
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;
|
|
if (np.is_absolute())
|
|
flags|=1;
|
|
if (np.get_property()!=StringName())
|
|
flags|=2;
|
|
|
|
encode_uint32(flags,buf+8);
|
|
|
|
buf+=12;
|
|
}
|
|
|
|
r_len+=12;
|
|
|
|
int total = np.get_name_count()+np.get_subname_count();
|
|
if (np.get_property()!=StringName())
|
|
total++;
|
|
|
|
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());
|
|
else
|
|
str=np.get_property();
|
|
|
|
CharString utf8 = str.utf8();
|
|
|
|
int pad = 0;
|
|
|
|
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();
|
|
}
|
|
|
|
|
|
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());
|
|
}
|
|
|
|
r_len+=4+utf8.length();
|
|
while (r_len%4)
|
|
r_len++; //pad
|
|
|
|
} break;
|
|
// math types
|
|
|
|
case Variant::VECTOR2: {
|
|
|
|
if (buf) {
|
|
Vector2 v2=p_variant;
|
|
encode_float(v2.x,&buf[0]);
|
|
encode_float(v2.y,&buf[4]);
|
|
|
|
}
|
|
|
|
r_len+=2*4;
|
|
|
|
} 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]);
|
|
}
|
|
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]);
|
|
}
|
|
|
|
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++) {
|
|
|
|
copymem(&buf[(i*2+j)*4],&val.elements[i][j],sizeof(float));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
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]);
|
|
}
|
|
|
|
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]);
|
|
}
|
|
|
|
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]);
|
|
}
|
|
|
|
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++) {
|
|
|
|
copymem(&buf[(i*3+j)*4],&val.elements[i][j],sizeof(float));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
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++) {
|
|
|
|
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]);
|
|
|
|
|
|
}
|
|
|
|
r_len+=12*4;
|
|
|
|
} break;
|
|
|
|
// misc types
|
|
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]);
|
|
}
|
|
|
|
r_len+=4*4;
|
|
|
|
} break;
|
|
case Variant::IMAGE: {
|
|
|
|
Image image = p_variant;
|
|
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]);
|
|
PoolVector<uint8_t>::Read r = data.read();
|
|
copymem(&buf[20],&r[0],ds);
|
|
}
|
|
|
|
int pad=0;
|
|
if (data.size()%4)
|
|
pad=4-data.size()%4;
|
|
|
|
r_len+=data.size()+5*4+pad;
|
|
|
|
} break;
|
|
/*case Variant::RESOURCE: {
|
|
|
|
ERR_EXPLAIN("Can't marshallize resources");
|
|
ERR_FAIL_V(ERR_INVALID_DATA); //no, i'm sorry, no go
|
|
} break;*/
|
|
case Variant::_RID:
|
|
case Variant::OBJECT: {
|
|
|
|
|
|
} break;
|
|
case Variant::INPUT_EVENT: {
|
|
|
|
|
|
InputEvent ie=p_variant;
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(ie.type,&buf[0]);
|
|
encode_uint32(ie.device,&buf[4]);
|
|
encode_uint32(0,&buf[8]);
|
|
}
|
|
|
|
int llen=12;
|
|
|
|
switch(ie.type) {
|
|
|
|
case InputEvent::KEY: {
|
|
|
|
if (buf) {
|
|
|
|
uint32_t mods=0;
|
|
if (ie.key.mod.shift)
|
|
mods|=KEY_MASK_SHIFT;
|
|
if (ie.key.mod.control)
|
|
mods|=KEY_MASK_CTRL;
|
|
if (ie.key.mod.alt)
|
|
mods|=KEY_MASK_ALT;
|
|
if (ie.key.mod.meta)
|
|
mods|=KEY_MASK_META;
|
|
|
|
encode_uint32(mods,&buf[llen]);
|
|
encode_uint32(ie.key.scancode,&buf[llen+4]);
|
|
}
|
|
llen+=8;
|
|
|
|
} break;
|
|
case InputEvent::MOUSE_BUTTON: {
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(ie.mouse_button.button_index,&buf[llen]);
|
|
}
|
|
llen+=4;
|
|
} break;
|
|
case InputEvent::JOYPAD_BUTTON: {
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(ie.joy_button.button_index,&buf[llen]);
|
|
}
|
|
llen+=4;
|
|
} break;
|
|
case InputEvent::SCREEN_TOUCH: {
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(ie.screen_touch.index,&buf[llen]);
|
|
}
|
|
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]);
|
|
}
|
|
llen+=8;
|
|
} break;
|
|
}
|
|
|
|
if (buf)
|
|
encode_uint32(llen,&buf[8]);
|
|
r_len+=llen;
|
|
|
|
|
|
// not supported
|
|
} break;
|
|
case Variant::DICTIONARY: {
|
|
|
|
Dictionary d = p_variant;
|
|
|
|
if (buf) {
|
|
encode_uint32(uint32_t(d.size()),buf);
|
|
buf+=4;
|
|
}
|
|
r_len+=4;
|
|
|
|
List<Variant> keys;
|
|
d.get_key_list(&keys);
|
|
|
|
|
|
for(List<Variant>::Element *E=keys.front();E;E=E->next()) {
|
|
|
|
/*
|
|
CharString utf8 = E->->utf8();
|
|
|
|
if (buf) {
|
|
encode_uint32(utf8.length()+1,buf);
|
|
buf+=4;
|
|
copymem(buf,utf8.get_data(),utf8.length()+1);
|
|
}
|
|
|
|
r_len+=4+utf8.length()+1;
|
|
while (r_len%4)
|
|
r_len++; //pad
|
|
*/
|
|
int 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;
|
|
if (buf)
|
|
buf += len;
|
|
}
|
|
|
|
} break;
|
|
case Variant::ARRAY: {
|
|
|
|
Array v = p_variant;
|
|
|
|
if (buf) {
|
|
encode_uint32(uint32_t(v.size()),buf);
|
|
buf+=4;
|
|
}
|
|
|
|
r_len+=4;
|
|
|
|
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;
|
|
if (buf)
|
|
buf+=len;
|
|
}
|
|
|
|
|
|
} break;
|
|
// arrays
|
|
case Variant::POOL_BYTE_ARRAY: {
|
|
|
|
PoolVector<uint8_t> data = p_variant;
|
|
int datalen=data.size();
|
|
int datasize=sizeof(uint8_t);
|
|
|
|
if (buf) {
|
|
encode_uint32(datalen,buf);
|
|
buf+=4;
|
|
PoolVector<uint8_t>::Read r = data.read();
|
|
copymem(buf,&r[0],datalen*datasize);
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
if (buf) {
|
|
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]);
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
if (buf) {
|
|
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]);
|
|
|
|
}
|
|
|
|
r_len+=4+datalen*datasize;
|
|
|
|
} break;
|
|
case Variant::POOL_STRING_ARRAY: {
|
|
|
|
|
|
PoolVector<String> data = p_variant;
|
|
int len=data.size();
|
|
|
|
if (buf) {
|
|
encode_uint32(len,buf);
|
|
buf+=4;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
r_len+=4+utf8.length()+1;
|
|
while (r_len%4) {
|
|
r_len++; //pad
|
|
if (buf)
|
|
buf++;
|
|
}
|
|
}
|
|
|
|
} break;
|
|
case Variant::POOL_VECTOR2_ARRAY: {
|
|
|
|
PoolVector<Vector2> data = p_variant;
|
|
int len=data.size();
|
|
|
|
if (buf) {
|
|
encode_uint32(len,buf);
|
|
buf+=4;
|
|
}
|
|
|
|
r_len+=4;
|
|
|
|
if (buf) {
|
|
|
|
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;
|
|
|
|
}
|
|
}
|
|
|
|
r_len+=4*2*len;
|
|
|
|
} break;
|
|
case Variant::POOL_VECTOR3_ARRAY: {
|
|
|
|
PoolVector<Vector3> data = p_variant;
|
|
int len=data.size();
|
|
|
|
if (buf) {
|
|
encode_uint32(len,buf);
|
|
buf+=4;
|
|
}
|
|
|
|
r_len+=4;
|
|
|
|
if (buf) {
|
|
|
|
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;
|
|
|
|
}
|
|
}
|
|
|
|
r_len+=4*3*len;
|
|
|
|
} break;
|
|
case Variant::POOL_COLOR_ARRAY: {
|
|
|
|
PoolVector<Color> data = p_variant;
|
|
int len=data.size();
|
|
|
|
if (buf) {
|
|
encode_uint32(len,buf);
|
|
buf+=4;
|
|
}
|
|
|
|
r_len+=4;
|
|
|
|
if (buf) {
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
r_len+=4*4*len;
|
|
|
|
} break;
|
|
default: { ERR_FAIL_V(ERR_BUG); }
|
|
}
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|