int64_t FileAccessNetworkClient::get_64() {
uint8_t buf[8];
client->get_data(buf,8);
return decode_uint64(buf);
}
int64_t StreamPeer::get_64() {
uint8_t buf[8];
get_data(buf, 8);
uint64_t r = decode_uint64(buf);
if (big_endian) {
r = BSWAP64(r);
}
return r;
}
void
decode_recur(DBusMessageIter *iter, int *err, alarm_recur_t *rec)
{
decode_uint64 (iter, err, &rec->mask_min);
decode_uint32 (iter, err, &rec->mask_hour);
decode_uint32 (iter, err, &rec->mask_mday);
decode_uint32 (iter, err, &rec->mask_wday);
decode_uint32 (iter, err, &rec->mask_mon);
decode_uint32 (iter, err, &rec->special);
}
int encode_int < uint64_t > ( uint64_t val, uint8_t * start, uint8_t * end )
{
int ret = encode_uint64 ( val, start, end );
if ( ret > 0 )
{
uint64_t val2;
int ret2 = decode_uint64 ( start, start + ret, & val2 );
assert ( ret == ret2 && val == val2 );
}
return ret;
}
bool GridMap::_set(const StringName &p_name, const Variant &p_value) {
String name = p_name;
if (name == "theme") {
set_theme(p_value);
} else if (name == "cell_size") {
set_cell_size(p_value);
} else if (name == "cell_octant_size") {
set_octant_size(p_value);
} else if (name == "cell_center_x") {
set_center_x(p_value);
} else if (name == "cell_center_y") {
set_center_y(p_value);
} else if (name == "cell_center_z") {
set_center_z(p_value);
} else if (name == "cell_scale") {
set_cell_scale(p_value);
/* } else if (name=="cells") {
PoolVector<int> cells = p_value;
int amount=cells.size();
PoolVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount&1,false); // not even
cell_map.clear();
for(int i=0;i<amount/3;i++) {
IndexKey ik;
ik.key=decode_uint64(&r[i*3]);
Cell cell;
cell.cell=uint32_t(r[i*+1]);
cell_map[ik]=cell;
}
_recreate_octant_data();*/
} else if (name == "data") {
Dictionary d = p_value;
if (d.has("cells")) {
PoolVector<int> cells = d["cells"];
int amount = cells.size();
PoolVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount % 3, false); // not even
cell_map.clear();
for (int i = 0; i < amount / 3; i++) {
IndexKey ik;
ik.key = decode_uint64((const uint8_t *)&r[i * 3]);
Cell cell;
cell.cell = decode_uint32((const uint8_t *)&r[i * 3 + 2]);
cell_map[ik] = cell;
}
}
_recreate_octant_data();
} else if (name.begins_with("areas/")) {
int which = name.get_slicec('/', 1).to_int();
String what = name.get_slicec('/', 2);
if (what == "bounds") {
ERR_FAIL_COND_V(area_map.has(which), false);
create_area(which, p_value);
return true;
}
ERR_FAIL_COND_V(!area_map.has(which), false);
if (what == "name")
area_set_name(which, p_value);
else if (what == "disable_distance")
area_set_portal_disable_distance(which, p_value);
else if (what == "exterior_portal")
area_set_portal_disable_color(which, p_value);
else
return false;
} else
return false;
return true;
}
bool GridMap::_set(const StringName &p_name, const Variant &p_value) {
String name = p_name;
if (name == "theme") {
set_theme(p_value);
} else if (name == "cell_size") {
if (p_value.get_type() == Variant::INT || p_value.get_type() == Variant::REAL) {
//compatibility
float cs = p_value;
set_cell_size(Vector3(cs, cs, cs));
} else {
set_cell_size(p_value);
}
} else if (name == "cell_octant_size") {
set_octant_size(p_value);
} else if (name == "cell_center_x") {
set_center_x(p_value);
} else if (name == "cell_center_y") {
set_center_y(p_value);
} else if (name == "cell_center_z") {
set_center_z(p_value);
} else if (name == "cell_scale") {
set_cell_scale(p_value);
/* } else if (name=="cells") {
PoolVector<int> cells = p_value;
int amount=cells.size();
PoolVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount&1,false); // not even
cell_map.clear();
for(int i=0;i<amount/3;i++) {
IndexKey ik;
ik.key=decode_uint64(&r[i*3]);
Cell cell;
cell.cell=uint32_t(r[i*+1]);
cell_map[ik]=cell;
}
_recreate_octant_data();*/
} else if (name == "data") {
Dictionary d = p_value;
if (d.has("cells")) {
PoolVector<int> cells = d["cells"];
int amount = cells.size();
PoolVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount % 3, false); // not even
cell_map.clear();
for (int i = 0; i < amount / 3; i++) {
IndexKey ik;
ik.key = decode_uint64((const uint8_t *)&r[i * 3]);
Cell cell;
cell.cell = decode_uint32((const uint8_t *)&r[i * 3 + 2]);
cell_map[ik] = cell;
}
}
_recreate_octant_data();
} else
return false;
return true;
}
static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
{
return decode_uint64(xdr, cookie);
}
static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
{
return decode_uint64(xdr, fileid);
}
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.position.x = decode_float(&buf[0]);
val.position.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.position.x = decode_float(&buf[0]);
val.position.y = decode_float(&buf[4]);
val.position.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::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::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;
}
