2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* marshalls.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2022-01-03 21:27:34 +01:00
|
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#include "marshalls.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
|
2021-06-04 18:03:15 +02:00
|
|
|
#include "core/object/ref_counted.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/os/keyboard.h"
|
2020-11-07 23:33:38 +01:00
|
|
|
#include "core/string/print_string.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
#include <limits.h>
|
2014-02-10 02:10:30 +01:00
|
|
|
#include <stdio.h>
|
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
void EncodedObjectAsID::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("set_object_id", "id"), &EncodedObjectAsID::set_object_id);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_object_id"), &EncodedObjectAsID::get_object_id);
|
2019-06-26 10:50:45 +02:00
|
|
|
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "object_id"), "set_object_id", "get_object_id");
|
2017-08-18 15:59:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void EncodedObjectAsID::set_object_id(ObjectID p_id) {
|
|
|
|
id = p_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
ObjectID EncodedObjectAsID::get_object_id() const {
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2021-08-09 19:28:08 +02:00
|
|
|
#define ERR_FAIL_ADD_OF(a, b, err) ERR_FAIL_COND_V(((int32_t)(b)) < 0 || ((int32_t)(a)) < 0 || ((int32_t)(a)) > INT_MAX - ((int32_t)(b)), err)
|
|
|
|
#define ERR_FAIL_MUL_OF(a, b, err) ERR_FAIL_COND_V(((int32_t)(a)) < 0 || ((int32_t)(b)) <= 0 || ((int32_t)(a)) > INT_MAX / ((int32_t)(b)), err)
|
2019-06-26 10:50:45 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
#define ENCODE_MASK 0xFF
|
|
|
|
#define ENCODE_FLAG_64 1 << 16
|
2017-08-18 15:59:31 +02:00
|
|
|
#define ENCODE_FLAG_OBJECT_AS_ID 1 << 16
|
2017-01-09 00:58:39 +01:00
|
|
|
|
2017-08-14 16:58:10 +02:00
|
|
|
static Error _decode_string(const uint8_t *&buf, int &len, int *r_len, String &r_string) {
|
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t strlen = decode_uint32(buf);
|
|
|
|
int32_t pad = 0;
|
|
|
|
|
|
|
|
// Handle padding
|
|
|
|
if (strlen % 4) {
|
|
|
|
pad = 4 - strlen % 4;
|
|
|
|
}
|
|
|
|
|
2017-08-14 16:58:10 +02:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2018-07-08 15:11:41 +02:00
|
|
|
|
|
|
|
// Ensure buffer is big enough
|
|
|
|
ERR_FAIL_ADD_OF(strlen, pad, ERR_FILE_EOF);
|
|
|
|
ERR_FAIL_COND_V(strlen < 0 || strlen + pad > len, ERR_FILE_EOF);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
|
|
|
String str;
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(str.parse_utf8((const char *)buf, strlen), ERR_INVALID_DATA);
|
2017-08-14 16:58:10 +02:00
|
|
|
r_string = str;
|
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
// Add padding
|
|
|
|
strlen += pad;
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
// Update buffer pos, left data count, and return size
|
2017-08-14 16:58:10 +02:00
|
|
|
buf += strlen;
|
|
|
|
len -= strlen;
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += 4 + strlen;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int *r_len, bool p_allow_objects) {
|
2017-03-05 16:44:50 +01:00
|
|
|
const uint8_t *buf = p_buffer;
|
|
|
|
int len = p_len;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2019-06-20 16:59:48 +02:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
uint32_t type = decode_uint32(buf);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V((type & ENCODE_MASK) >= Variant::VARIANT_MAX, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
*r_len = 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
// Note: We cannot use sizeof(real_t) for decoding, in case a different size is encoded.
|
|
|
|
// Decoding math types always checks for the encoded size, while encoding always uses compilation setting.
|
|
|
|
// This does lead to some code duplication for decoding, but compatibility is the priority.
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (type & ENCODE_MASK) {
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::NIL: {
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = Variant();
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::BOOL: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
bool val = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = val;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::INT: {
|
2017-03-05 16:44:50 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(len < 8, ERR_INVALID_DATA);
|
2017-01-09 00:58:39 +01:00
|
|
|
int64_t val = decode_uint64(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = val;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 8;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-01-09 00:58:39 +01:00
|
|
|
|
|
|
|
} else {
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2017-01-09 00:58:39 +01:00
|
|
|
int32_t val = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = val;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::FLOAT: {
|
2017-03-05 16:44:50 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
2020-03-17 04:11:41 +01:00
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double), ERR_INVALID_DATA);
|
2017-01-09 00:58:39 +01:00
|
|
|
double val = decode_double(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = val;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += sizeof(double);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-01-09 00:58:39 +01:00
|
|
|
} else {
|
2020-03-17 04:11:41 +01:00
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float), ERR_INVALID_DATA);
|
2017-01-09 00:58:39 +01:00
|
|
|
float val = decode_float(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = val;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += sizeof(float);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::STRING: {
|
|
|
|
String str;
|
2017-08-14 16:58:10 +02:00
|
|
|
Error err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2017-08-14 16:58:10 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = str;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
|
2017-12-06 21:36:34 +01:00
|
|
|
// math types
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::VECTOR2: {
|
|
|
|
Vector2 val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 2, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_double(&buf[0]);
|
|
|
|
val.y = decode_double(&buf[sizeof(double)]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 2;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 2, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_float(&buf[0]);
|
|
|
|
val.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 2;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-24 17:00:40 +01:00
|
|
|
} break;
|
2020-02-22 04:26:41 +01:00
|
|
|
case Variant::VECTOR2I: {
|
|
|
|
ERR_FAIL_COND_V(len < 4 * 2, ERR_INVALID_DATA);
|
|
|
|
Vector2i val;
|
|
|
|
val.x = decode_uint32(&buf[0]);
|
|
|
|
val.y = decode_uint32(&buf[4]);
|
|
|
|
r_variant = val;
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-02-22 04:26:41 +01:00
|
|
|
(*r_len) += 4 * 2;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-02-22 04:26:41 +01:00
|
|
|
|
2020-02-24 17:00:40 +01:00
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::RECT2: {
|
|
|
|
Rect2 val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 4, ERR_INVALID_DATA);
|
|
|
|
val.position.x = decode_double(&buf[0]);
|
|
|
|
val.position.y = decode_double(&buf[sizeof(double)]);
|
|
|
|
val.size.x = decode_double(&buf[sizeof(double) * 2]);
|
|
|
|
val.size.y = decode_double(&buf[sizeof(double) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 4;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 4, ERR_INVALID_DATA);
|
|
|
|
val.position.x = decode_float(&buf[0]);
|
|
|
|
val.position.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
val.size.x = decode_float(&buf[sizeof(float) * 2]);
|
|
|
|
val.size.y = decode_float(&buf[sizeof(float) * 3]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 4;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-22 04:26:41 +01:00
|
|
|
} break;
|
|
|
|
case Variant::RECT2I: {
|
|
|
|
ERR_FAIL_COND_V(len < 4 * 4, ERR_INVALID_DATA);
|
|
|
|
Rect2i val;
|
|
|
|
val.position.x = decode_uint32(&buf[0]);
|
|
|
|
val.position.y = decode_uint32(&buf[4]);
|
|
|
|
val.size.x = decode_uint32(&buf[8]);
|
|
|
|
val.size.y = decode_uint32(&buf[12]);
|
|
|
|
r_variant = val;
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-02-22 04:26:41 +01:00
|
|
|
(*r_len) += 4 * 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-02-22 04:26:41 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::VECTOR3: {
|
|
|
|
Vector3 val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 3, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_double(&buf[0]);
|
|
|
|
val.y = decode_double(&buf[sizeof(double)]);
|
|
|
|
val.z = decode_double(&buf[sizeof(double) * 2]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 3;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 3, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_float(&buf[0]);
|
|
|
|
val.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
val.z = decode_float(&buf[sizeof(float) * 2]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 3;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-22 04:26:41 +01:00
|
|
|
} break;
|
|
|
|
case Variant::VECTOR3I: {
|
|
|
|
ERR_FAIL_COND_V(len < 4 * 3, ERR_INVALID_DATA);
|
|
|
|
Vector3i val;
|
|
|
|
val.x = decode_uint32(&buf[0]);
|
|
|
|
val.y = decode_uint32(&buf[4]);
|
|
|
|
val.z = decode_uint32(&buf[8]);
|
|
|
|
r_variant = val;
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-02-22 04:26:41 +01:00
|
|
|
(*r_len) += 4 * 3;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-02-22 04:26:41 +01:00
|
|
|
|
2013-04-10 10:37:04 +02:00
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::TRANSFORM2D: {
|
|
|
|
Transform2D val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 6, ERR_INVALID_DATA);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 2; j++) {
|
|
|
|
val.elements[i][j] = decode_double(&buf[(i * 2 + j) * sizeof(double)]);
|
|
|
|
}
|
2013-04-10 10:37:04 +02:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 6;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 6, ERR_INVALID_DATA);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 2; j++) {
|
|
|
|
val.elements[i][j] = decode_float(&buf[(i * 2 + j) * sizeof(float)]);
|
|
|
|
}
|
|
|
|
}
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 6;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::PLANE: {
|
|
|
|
Plane val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 4, ERR_INVALID_DATA);
|
|
|
|
val.normal.x = decode_double(&buf[0]);
|
|
|
|
val.normal.y = decode_double(&buf[sizeof(double)]);
|
|
|
|
val.normal.z = decode_double(&buf[sizeof(double) * 2]);
|
|
|
|
val.d = decode_double(&buf[sizeof(double) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 4;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 4, ERR_INVALID_DATA);
|
|
|
|
val.normal.x = decode_float(&buf[0]);
|
|
|
|
val.normal.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
val.normal.z = decode_float(&buf[sizeof(float) * 2]);
|
|
|
|
val.d = decode_float(&buf[sizeof(float) * 3]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 4;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2021-01-20 08:02:02 +01:00
|
|
|
case Variant::QUATERNION: {
|
|
|
|
Quaternion val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 4, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_double(&buf[0]);
|
|
|
|
val.y = decode_double(&buf[sizeof(double)]);
|
|
|
|
val.z = decode_double(&buf[sizeof(double) * 2]);
|
|
|
|
val.w = decode_double(&buf[sizeof(double) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 4;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 4, ERR_INVALID_DATA);
|
|
|
|
val.x = decode_float(&buf[0]);
|
|
|
|
val.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
val.z = decode_float(&buf[sizeof(float) * 2]);
|
|
|
|
val.w = decode_float(&buf[sizeof(float) * 3]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 4;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2017-11-17 03:09:00 +01:00
|
|
|
case Variant::AABB: {
|
|
|
|
AABB val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 6, ERR_INVALID_DATA);
|
|
|
|
val.position.x = decode_double(&buf[0]);
|
|
|
|
val.position.y = decode_double(&buf[sizeof(double)]);
|
|
|
|
val.position.z = decode_double(&buf[sizeof(double) * 2]);
|
|
|
|
val.size.x = decode_double(&buf[sizeof(double) * 3]);
|
|
|
|
val.size.y = decode_double(&buf[sizeof(double) * 4]);
|
|
|
|
val.size.z = decode_double(&buf[sizeof(double) * 5]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 6;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 6, ERR_INVALID_DATA);
|
|
|
|
val.position.x = decode_float(&buf[0]);
|
|
|
|
val.position.y = decode_float(&buf[sizeof(float)]);
|
|
|
|
val.position.z = decode_float(&buf[sizeof(float) * 2]);
|
|
|
|
val.size.x = decode_float(&buf[sizeof(float) * 3]);
|
|
|
|
val.size.y = decode_float(&buf[sizeof(float) * 4]);
|
|
|
|
val.size.z = decode_float(&buf[sizeof(float) * 5]);
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 6;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::BASIS: {
|
|
|
|
Basis val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 9, ERR_INVALID_DATA);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
val.elements[i][j] = decode_double(&buf[(i * 3 + j) * sizeof(double)]);
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 9;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 9, ERR_INVALID_DATA);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
val.elements[i][j] = decode_float(&buf[(i * 3 + j) * sizeof(float)]);
|
|
|
|
}
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 9;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2021-04-28 09:36:08 +02:00
|
|
|
case Variant::TRANSFORM3D: {
|
2020-10-17 07:08:21 +02:00
|
|
|
Transform3D val;
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(double) * 12, ERR_INVALID_DATA);
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
|
|
|
val.basis.elements[i][j] = decode_double(&buf[(i * 3 + j) * sizeof(double)]);
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
val.origin[0] = decode_double(&buf[sizeof(double) * 9]);
|
|
|
|
val.origin[1] = decode_double(&buf[sizeof(double) * 10]);
|
|
|
|
val.origin[2] = decode_double(&buf[sizeof(double) * 11]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(double) * 12;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V((size_t)len < sizeof(float) * 12, ERR_INVALID_DATA);
|
|
|
|
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) * sizeof(float)]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
val.origin[0] = decode_float(&buf[sizeof(float) * 9]);
|
|
|
|
val.origin[1] = decode_float(&buf[sizeof(float) * 10]);
|
|
|
|
val.origin[2] = decode_float(&buf[sizeof(float) * 11]);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += sizeof(float) * 12;
|
|
|
|
}
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_variant = val;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
// misc types
|
|
|
|
case Variant::COLOR: {
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(len < 4 * 4, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
Color val;
|
2017-03-05 16:44:50 +01:00
|
|
|
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;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4 * 4; // Colors should always be in single-precision.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-20 22:58:05 +01:00
|
|
|
case Variant::STRING_NAME: {
|
|
|
|
String str;
|
|
|
|
Error err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2020-02-20 22:58:05 +01:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2020-02-20 22:58:05 +01:00
|
|
|
r_variant = StringName(str);
|
|
|
|
|
|
|
|
} break;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::NODE_PATH: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t strlen = decode_uint32(buf);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
if (strlen & 0x80000000) {
|
2014-03-14 02:57:24 +01:00
|
|
|
//new format
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 12, ERR_INVALID_DATA);
|
2014-03-14 02:57:24 +01:00
|
|
|
Vector<StringName> names;
|
|
|
|
Vector<StringName> subnames;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
uint32_t namecount = strlen &= 0x7FFFFFFF;
|
|
|
|
uint32_t subnamecount = decode_uint32(buf + 4);
|
|
|
|
uint32_t flags = decode_uint32(buf + 8);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
len -= 12;
|
|
|
|
buf += 12;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (flags & 2) { // Obsolete format with property separate from subpath
|
2017-05-30 22:20:15 +02:00
|
|
|
subnamecount++;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-05-30 22:20:15 +02:00
|
|
|
|
2017-08-31 23:30:35 +02:00
|
|
|
uint32_t total = namecount + subnamecount;
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 12;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2017-08-31 23:30:35 +02:00
|
|
|
for (uint32_t i = 0; i < total; i++) {
|
2014-03-14 02:57:24 +01:00
|
|
|
String str;
|
2018-07-08 15:11:41 +02:00
|
|
|
Error err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2018-07-08 15:11:41 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (i < namecount) {
|
2014-03-14 02:57:24 +01:00
|
|
|
names.push_back(str);
|
2020-05-14 16:41:43 +02:00
|
|
|
} else {
|
2017-05-30 22:20:15 +02:00
|
|
|
subnames.push_back(str);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
}
|
|
|
|
|
2017-05-30 22:20:15 +02:00
|
|
|
r_variant = NodePath(names, subnames, flags & 1);
|
2014-03-14 02:57:24 +01:00
|
|
|
|
|
|
|
} else {
|
|
|
|
//old format, just a string
|
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_V(ERR_INVALID_DATA);
|
2014-03-14 02:57:24 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2020-11-09 14:53:05 +01:00
|
|
|
case Variant::RID: {
|
2014-02-10 02:10:30 +01:00
|
|
|
r_variant = RID();
|
|
|
|
} break;
|
|
|
|
case Variant::OBJECT: {
|
2017-08-18 15:59:31 +02:00
|
|
|
if (type & ENCODE_FLAG_OBJECT_AS_ID) {
|
|
|
|
//this _is_ allowed
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(len < 8, ERR_INVALID_DATA);
|
2020-02-12 18:24:06 +01:00
|
|
|
ObjectID val = ObjectID(decode_uint64(buf));
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-08-18 15:59:31 +02:00
|
|
|
(*r_len) += 8;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2020-02-12 18:24:06 +01:00
|
|
|
if (val.is_null()) {
|
2020-04-02 01:20:12 +02:00
|
|
|
r_variant = (Object *)nullptr;
|
2017-08-18 15:59:31 +02:00
|
|
|
} else {
|
|
|
|
Ref<EncodedObjectAsID> obj_as_id;
|
2021-06-18 00:03:09 +02:00
|
|
|
obj_as_id.instantiate();
|
2017-08-18 15:59:31 +02:00
|
|
|
obj_as_id->set_object_id(val);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
r_variant = obj_as_id;
|
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V(!p_allow_objects, ERR_UNAUTHORIZED);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
String str;
|
|
|
|
Error err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2017-08-18 15:59:31 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2021-12-09 10:42:46 +01:00
|
|
|
if (str.is_empty()) {
|
2020-04-02 01:20:12 +02:00
|
|
|
r_variant = (Object *)nullptr;
|
2017-08-18 15:59:31 +02:00
|
|
|
} else {
|
2021-06-18 00:03:09 +02:00
|
|
|
Object *obj = ClassDB::instantiate(str);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
ERR_FAIL_COND_V(!obj, ERR_UNAVAILABLE);
|
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2017-08-14 16:58:10 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
str = String();
|
|
|
|
err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2017-08-18 15:59:31 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-18 15:59:31 +02:00
|
|
|
|
|
|
|
Variant value;
|
|
|
|
int used;
|
|
|
|
err = decode_variant(value, buf, len, &used, p_allow_objects);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2017-08-18 15:59:31 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-18 15:59:31 +02:00
|
|
|
|
|
|
|
buf += used;
|
|
|
|
len -= used;
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += used;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj->set(str, value);
|
|
|
|
}
|
|
|
|
|
2021-06-04 18:03:15 +02:00
|
|
|
if (Object::cast_to<RefCounted>(obj)) {
|
|
|
|
REF ref = REF(Object::cast_to<RefCounted>(obj));
|
2017-08-18 15:59:31 +02:00
|
|
|
r_variant = ref;
|
|
|
|
} else {
|
|
|
|
r_variant = obj;
|
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-19 20:27:19 +01:00
|
|
|
case Variant::CALLABLE: {
|
|
|
|
r_variant = Callable();
|
|
|
|
} break;
|
|
|
|
case Variant::SIGNAL: {
|
|
|
|
r_variant = Signal();
|
|
|
|
} break;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::DICTIONARY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
// bool shared = count&0x80000000;
|
|
|
|
count &= 0x7FFFFFFF;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Dictionary d;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int i = 0; i < count; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Variant key, value;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
int used;
|
2017-08-14 16:58:10 +02:00
|
|
|
Error err = decode_variant(key, buf, len, &used, p_allow_objects);
|
2019-09-25 10:28:50 +02:00
|
|
|
ERR_FAIL_COND_V_MSG(err != OK, err, "Error when trying to decode Variant.");
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += used;
|
|
|
|
len -= used;
|
2014-02-10 02:10:30 +01:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += used;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-08-14 16:58:10 +02:00
|
|
|
err = decode_variant(value, buf, len, &used, p_allow_objects);
|
2019-09-25 10:28:50 +02:00
|
|
|
ERR_FAIL_COND_V_MSG(err != OK, err, "Error when trying to decode Variant.");
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += used;
|
|
|
|
len -= used;
|
2014-02-10 02:10:30 +01:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += used;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
d[key] = value;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = d;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
// bool shared = count&0x80000000;
|
|
|
|
count &= 0x7FFFFFFF;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Array varr;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int i = 0; i < count; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
int used = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
Variant v;
|
2017-08-14 16:58:10 +02:00
|
|
|
Error err = decode_variant(v, buf, len, &used, p_allow_objects);
|
2019-09-25 10:28:50 +02:00
|
|
|
ERR_FAIL_COND_V_MSG(err != OK, err, "Error when trying to decode Variant.");
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += used;
|
|
|
|
len -= used;
|
2014-02-10 02:10:30 +01:00
|
|
|
varr.push_back(v);
|
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += used;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = varr;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
|
|
|
|
// arrays
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_BYTE_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_COND_V(count < 0 || count > len, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<uint8_t> data;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (count) {
|
|
|
|
data.resize(count);
|
2020-02-17 22:06:54 +01:00
|
|
|
uint8_t *w = data.ptrw();
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int32_t i = 0; i < count; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
w[i] = buf[i];
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = data;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_len) {
|
2020-05-14 16:41:43 +02:00
|
|
|
if (count % 4) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 4 - count % 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 4 + count;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::PACKED_INT32_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_MUL_OF(count, 4, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * 4 > len, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
Vector<int32_t> data;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (count) {
|
|
|
|
//const int*rbuf=(const int*)buf;
|
|
|
|
data.resize(count);
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
int32_t *w = data.ptrw();
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int32_t i = 0; i < count; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
w[i] = decode_uint32(&buf[i * 4]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = Variant(data);
|
2014-02-10 02:10:30 +01:00
|
|
|
if (r_len) {
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
(*r_len) += 4 + count * sizeof(int32_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::PACKED_INT64_ARRAY: {
|
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2021-08-02 13:34:06 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
|
|
|
ERR_FAIL_MUL_OF(count, 8, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * 8 > len, ERR_INVALID_DATA);
|
|
|
|
|
|
|
|
Vector<int64_t> data;
|
|
|
|
|
|
|
|
if (count) {
|
|
|
|
//const int*rbuf=(const int*)buf;
|
|
|
|
data.resize(count);
|
|
|
|
int64_t *w = data.ptrw();
|
|
|
|
for (int64_t i = 0; i < count; i++) {
|
|
|
|
w[i] = decode_uint64(&buf[i * 8]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
r_variant = Variant(data);
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += 4 + count * sizeof(int64_t);
|
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::PACKED_FLOAT32_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_MUL_OF(count, 4, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * 4 > len, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<float> data;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (count) {
|
|
|
|
//const float*rbuf=(const float*)buf;
|
|
|
|
data.resize(count);
|
2020-02-17 22:06:54 +01:00
|
|
|
float *w = data.ptrw();
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int32_t i = 0; i < count; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
w[i] = decode_float(&buf[i * 4]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = data;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += 4 + count * sizeof(float);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
} break;
|
|
|
|
case Variant::PACKED_FLOAT64_ARRAY: {
|
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2021-08-02 13:34:06 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
|
|
|
ERR_FAIL_MUL_OF(count, 8, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * 8 > len, ERR_INVALID_DATA);
|
|
|
|
|
|
|
|
Vector<double> data;
|
|
|
|
|
|
|
|
if (count) {
|
|
|
|
data.resize(count);
|
|
|
|
double *w = data.ptrw();
|
|
|
|
for (int64_t i = 0; i < count; i++) {
|
|
|
|
w[i] = decode_double(&buf[i * 8]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
r_variant = data;
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += 4 + count * sizeof(double);
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_STRING_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<String> strings;
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int32_t i = 0; i < count; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
String str;
|
2018-07-08 15:11:41 +02:00
|
|
|
Error err = _decode_string(buf, len, r_len, str);
|
2020-05-14 16:41:43 +02:00
|
|
|
if (err) {
|
2018-07-08 15:11:41 +02:00
|
|
|
return err;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
strings.push_back(str);
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = strings;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2013-04-10 10:37:04 +02:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_VECTOR2_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<Vector2> varray;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_MUL_OF(count, sizeof(double) * 2, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * sizeof(double) * 2 > (size_t)len, ERR_INVALID_DATA);
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += 4; // Size of count number.
|
2013-04-10 10:37:04 +02:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (count) {
|
|
|
|
varray.resize(count);
|
|
|
|
Vector2 *w = varray.ptrw();
|
|
|
|
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
|
|
w[i].x = decode_double(buf + i * sizeof(double) * 2 + sizeof(double) * 0);
|
|
|
|
w[i].y = decode_double(buf + i * sizeof(double) * 2 + sizeof(double) * 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int adv = sizeof(double) * 2 * count;
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += adv;
|
|
|
|
}
|
|
|
|
len -= adv;
|
|
|
|
buf += adv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_MUL_OF(count, sizeof(float) * 2, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * sizeof(float) * 2 > (size_t)len, ERR_INVALID_DATA);
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (count) {
|
|
|
|
varray.resize(count);
|
|
|
|
Vector2 *w = varray.ptrw();
|
|
|
|
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
|
|
w[i].x = decode_float(buf + i * sizeof(float) * 2 + sizeof(float) * 0);
|
|
|
|
w[i].y = decode_float(buf + i * sizeof(float) * 2 + sizeof(float) * 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int adv = sizeof(float) * 2 * count;
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += adv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = varray;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_VECTOR3_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<Vector3> varray;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (type & ENCODE_FLAG_64) {
|
|
|
|
ERR_FAIL_MUL_OF(count, sizeof(double) * 3, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * sizeof(double) * 3 > (size_t)len, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += 4; // Size of count number.
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (count) {
|
|
|
|
varray.resize(count);
|
|
|
|
Vector3 *w = varray.ptrw();
|
|
|
|
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
|
|
w[i].x = decode_double(buf + i * sizeof(double) * 3 + sizeof(double) * 0);
|
|
|
|
w[i].y = decode_double(buf + i * sizeof(double) * 3 + sizeof(double) * 1);
|
|
|
|
w[i].z = decode_double(buf + i * sizeof(double) * 3 + sizeof(double) * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
int adv = sizeof(double) * 3 * count;
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += adv;
|
|
|
|
}
|
|
|
|
len -= adv;
|
|
|
|
buf += adv;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ERR_FAIL_MUL_OF(count, sizeof(float) * 3, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * sizeof(float) * 3 > (size_t)len, ERR_INVALID_DATA);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
if (count) {
|
|
|
|
varray.resize(count);
|
|
|
|
Vector3 *w = varray.ptrw();
|
|
|
|
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
|
|
w[i].x = decode_float(buf + i * sizeof(float) * 3 + sizeof(float) * 0);
|
|
|
|
w[i].y = decode_float(buf + i * sizeof(float) * 3 + sizeof(float) * 1);
|
|
|
|
w[i].z = decode_float(buf + i * sizeof(float) * 3 + sizeof(float) * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
int adv = sizeof(float) * 3 * count;
|
|
|
|
|
|
|
|
if (r_len) {
|
|
|
|
(*r_len) += adv;
|
|
|
|
}
|
|
|
|
len -= adv;
|
|
|
|
buf += adv;
|
|
|
|
}
|
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = varray;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_COLOR_ARRAY: {
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
|
2018-07-08 15:11:41 +02:00
|
|
|
int32_t count = decode_uint32(buf);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 4;
|
|
|
|
len -= 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
ERR_FAIL_MUL_OF(count, 4 * 4, ERR_INVALID_DATA);
|
|
|
|
ERR_FAIL_COND_V(count < 0 || count * 4 * 4 > len, ERR_INVALID_DATA);
|
|
|
|
|
2020-02-17 22:06:54 +01:00
|
|
|
Vector<Color> carray;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (r_len) {
|
2020-03-17 04:11:41 +01:00
|
|
|
(*r_len) += 4; // Size of count number.
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count) {
|
|
|
|
carray.resize(count);
|
2020-02-17 22:06:54 +01:00
|
|
|
Color *w = carray.ptrw();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2018-07-08 15:11:41 +02:00
|
|
|
for (int32_t i = 0; i < count; i++) {
|
2020-03-17 04:11:41 +01:00
|
|
|
// Colors should always be in single-precision.
|
2017-03-05 16:44:50 +01:00
|
|
|
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);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int adv = 4 * 4 * count;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (r_len) {
|
2017-03-05 16:44:50 +01:00
|
|
|
(*r_len) += adv;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_variant = carray;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2019-04-09 17:08:36 +02:00
|
|
|
default: {
|
|
|
|
ERR_FAIL_V(ERR_BUG);
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
2017-08-14 16:58:10 +02:00
|
|
|
static void _encode_string(const String &p_string, uint8_t *&buf, int &r_len) {
|
|
|
|
CharString utf8 = p_string.utf8();
|
|
|
|
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(utf8.length(), buf);
|
|
|
|
buf += 4;
|
2021-04-27 16:19:21 +02:00
|
|
|
memcpy(buf, utf8.get_data(), utf8.length());
|
2017-08-21 16:20:13 +02:00
|
|
|
buf += utf8.length();
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 4 + utf8.length();
|
2017-08-21 16:20:13 +02:00
|
|
|
while (r_len % 4) {
|
2017-08-14 16:58:10 +02:00
|
|
|
r_len++; //pad
|
2017-08-21 16:20:13 +02:00
|
|
|
if (buf) {
|
2018-03-04 18:45:33 +01:00
|
|
|
*(buf++) = 0;
|
2017-08-21 16:20:13 +02:00
|
|
|
}
|
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
|
|
|
|
2021-07-30 15:43:01 +02:00
|
|
|
Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bool p_full_objects, int p_depth) {
|
|
|
|
ERR_FAIL_COND_V_MSG(p_depth > Variant::MAX_RECURSION_DEPTH, ERR_OUT_OF_MEMORY, "Potential inifite recursion detected. Bailing.");
|
2017-03-05 16:44:50 +01:00
|
|
|
uint8_t *buf = r_buffer;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len = 0;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
uint32_t flags = 0;
|
2017-01-09 00:58:39 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (p_variant.get_type()) {
|
2017-01-09 00:58:39 +01:00
|
|
|
case Variant::INT: {
|
|
|
|
int64_t val = p_variant;
|
2018-09-18 18:31:37 +02:00
|
|
|
if (val > (int64_t)INT_MAX || val < (int64_t)INT_MIN) {
|
2017-03-05 16:44:50 +01:00
|
|
|
flags |= ENCODE_FLAG_64;
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::FLOAT: {
|
2017-01-09 00:58:39 +01:00
|
|
|
double d = p_variant;
|
|
|
|
float f = d;
|
2017-03-05 16:44:50 +01:00
|
|
|
if (double(f) != d) {
|
2020-03-17 04:11:41 +01:00
|
|
|
flags |= ENCODE_FLAG_64;
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
|
|
|
} break;
|
2017-08-18 15:59:31 +02:00
|
|
|
case Variant::OBJECT: {
|
2020-01-09 17:59:33 +01:00
|
|
|
// Test for potential wrong values sent by the debugger when it breaks.
|
2020-02-13 20:03:10 +01:00
|
|
|
Object *obj = p_variant.get_validated_object();
|
|
|
|
if (!obj) {
|
2021-06-07 10:17:32 +02:00
|
|
|
// Object is invalid, send a nullptr instead.
|
2020-01-09 17:59:33 +01:00
|
|
|
if (buf) {
|
|
|
|
encode_uint32(Variant::NIL, buf);
|
|
|
|
}
|
|
|
|
r_len += 4;
|
|
|
|
return OK;
|
|
|
|
}
|
2020-02-13 20:03:10 +01:00
|
|
|
|
2019-03-28 09:40:31 +01:00
|
|
|
if (!p_full_objects) {
|
2017-08-18 15:59:31 +02:00
|
|
|
flags |= ENCODE_FLAG_OBJECT_AS_ID;
|
|
|
|
}
|
|
|
|
} break;
|
2019-04-09 17:08:36 +02:00
|
|
|
default: {
|
|
|
|
} // nothing to do at this stage
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(p_variant.get_type() | flags, buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
switch (p_variant.get_type()) {
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::NIL: {
|
|
|
|
//nothing to do
|
|
|
|
} break;
|
|
|
|
case Variant::BOOL: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(p_variant.operator bool(), buf);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::INT: {
|
2018-09-18 18:31:37 +02:00
|
|
|
if (flags & ENCODE_FLAG_64) {
|
2017-01-09 00:58:39 +01:00
|
|
|
//64 bits
|
|
|
|
if (buf) {
|
2018-10-02 20:21:08 +02:00
|
|
|
encode_uint64(p_variant.operator int64_t(), buf);
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 8;
|
2017-01-09 00:58:39 +01:00
|
|
|
} else {
|
|
|
|
if (buf) {
|
2018-10-02 20:21:08 +02:00
|
|
|
encode_uint32(p_variant.operator int32_t(), buf);
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::FLOAT: {
|
2018-09-18 18:31:37 +02:00
|
|
|
if (flags & ENCODE_FLAG_64) {
|
2017-01-09 00:58:39 +01:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_double(p_variant.operator double(), buf);
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 8;
|
2017-01-09 00:58:39 +01:00
|
|
|
|
|
|
|
} else {
|
|
|
|
if (buf) {
|
2017-04-11 19:17:56 +02:00
|
|
|
encode_float(p_variant.operator float(), buf);
|
2017-01-09 00:58:39 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
2014-03-14 02:57:24 +01:00
|
|
|
case Variant::NODE_PATH: {
|
2017-03-05 16:44:50 +01:00
|
|
|
NodePath np = p_variant;
|
2014-03-14 02:57:24 +01:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(uint32_t(np.get_name_count()) | 0x80000000, buf); //for compatibility with the old format
|
|
|
|
encode_uint32(np.get_subname_count(), buf + 4);
|
2019-02-12 21:10:08 +01:00
|
|
|
uint32_t np_flags = 0;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (np.is_absolute()) {
|
2019-02-12 21:10:08 +01:00
|
|
|
np_flags |= 1;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2019-02-12 21:10:08 +01:00
|
|
|
encode_uint32(np_flags, buf + 8);
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += 12;
|
2014-03-14 02:57:24 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 12;
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
int total = np.get_name_count() + np.get_subname_count();
|
2014-03-14 02:57:24 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < total; i++) {
|
2014-03-14 02:57:24 +01:00
|
|
|
String str;
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (i < np.get_name_count()) {
|
2017-03-05 16:44:50 +01:00
|
|
|
str = np.get_name(i);
|
2020-05-14 16:41:43 +02:00
|
|
|
} else {
|
2017-05-30 22:20:15 +02:00
|
|
|
str = np.get_subname(i - np.get_name_count());
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
|
|
|
|
CharString utf8 = str.utf8();
|
|
|
|
|
|
|
|
int pad = 0;
|
|
|
|
|
2020-05-14 16:41:43 +02:00
|
|
|
if (utf8.length() % 4) {
|
2017-03-05 16:44:50 +01:00
|
|
|
pad = 4 - utf8.length() % 4;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-03-14 02:57:24 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(utf8.length(), buf);
|
|
|
|
buf += 4;
|
2021-04-27 16:19:21 +02:00
|
|
|
memcpy(buf, utf8.get_data(), utf8.length());
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += pad + utf8.length();
|
2014-03-14 02:57:24 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 + utf8.length() + pad;
|
2014-03-14 02:57:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
2020-12-08 19:58:49 +01:00
|
|
|
case Variant::STRING:
|
2020-02-20 22:58:05 +01:00
|
|
|
case Variant::STRING_NAME: {
|
|
|
|
_encode_string(p_variant, buf, r_len);
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
|
2017-12-06 21:36:34 +01:00
|
|
|
// math types
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::VECTOR2: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector2 v2 = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(v2.x, &buf[0]);
|
|
|
|
encode_real(v2.y, &buf[sizeof(real_t)]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 2 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-24 17:00:40 +01:00
|
|
|
} break;
|
2020-02-22 04:26:41 +01:00
|
|
|
case Variant::VECTOR2I: {
|
|
|
|
if (buf) {
|
|
|
|
Vector2i v2 = p_variant;
|
|
|
|
encode_uint32(v2.x, &buf[0]);
|
|
|
|
encode_uint32(v2.y, &buf[4]);
|
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 2 * 4;
|
|
|
|
|
2020-02-24 17:00:40 +01:00
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::RECT2: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Rect2 r2 = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(r2.position.x, &buf[0]);
|
|
|
|
encode_real(r2.position.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(r2.size.x, &buf[sizeof(real_t) * 2]);
|
|
|
|
encode_real(r2.size.y, &buf[sizeof(real_t) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 4 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-22 04:26:41 +01:00
|
|
|
} break;
|
|
|
|
case Variant::RECT2I: {
|
|
|
|
if (buf) {
|
|
|
|
Rect2i r2 = p_variant;
|
|
|
|
encode_uint32(r2.position.x, &buf[0]);
|
|
|
|
encode_uint32(r2.position.y, &buf[4]);
|
|
|
|
encode_uint32(r2.size.x, &buf[8]);
|
|
|
|
encode_uint32(r2.size.y, &buf[12]);
|
|
|
|
}
|
|
|
|
r_len += 4 * 4;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::VECTOR3: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Vector3 v3 = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(v3.x, &buf[0]);
|
|
|
|
encode_real(v3.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(v3.z, &buf[sizeof(real_t) * 2]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 3 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2020-02-22 04:26:41 +01:00
|
|
|
} break;
|
|
|
|
case Variant::VECTOR3I: {
|
|
|
|
if (buf) {
|
|
|
|
Vector3i v3 = p_variant;
|
|
|
|
encode_uint32(v3.x, &buf[0]);
|
|
|
|
encode_uint32(v3.y, &buf[4]);
|
|
|
|
encode_uint32(v3.z, &buf[8]);
|
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 3 * 4;
|
|
|
|
|
2013-04-10 10:37:04 +02:00
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::TRANSFORM2D: {
|
2013-04-10 10:37:04 +02:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Transform2D val = p_variant;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 2; j++) {
|
2020-03-17 04:11:41 +01:00
|
|
|
memcpy(&buf[(i * 2 + j) * sizeof(real_t)], &val.elements[i][j], sizeof(real_t));
|
2013-04-10 10:37:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 6 * sizeof(real_t);
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::PLANE: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Plane p = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(p.normal.x, &buf[0]);
|
|
|
|
encode_real(p.normal.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(p.normal.z, &buf[sizeof(real_t) * 2]);
|
|
|
|
encode_real(p.d, &buf[sizeof(real_t) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 4 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2021-01-20 08:02:02 +01:00
|
|
|
case Variant::QUATERNION: {
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2021-01-20 08:02:02 +01:00
|
|
|
Quaternion q = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(q.x, &buf[0]);
|
|
|
|
encode_real(q.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(q.z, &buf[sizeof(real_t) * 2]);
|
|
|
|
encode_real(q.w, &buf[sizeof(real_t) * 3]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 4 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2017-11-17 03:09:00 +01:00
|
|
|
case Variant::AABB: {
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2017-11-17 03:09:00 +01:00
|
|
|
AABB aabb = p_variant;
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(aabb.position.x, &buf[0]);
|
|
|
|
encode_real(aabb.position.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(aabb.position.z, &buf[sizeof(real_t) * 2]);
|
|
|
|
encode_real(aabb.size.x, &buf[sizeof(real_t) * 3]);
|
|
|
|
encode_real(aabb.size.y, &buf[sizeof(real_t) * 4]);
|
|
|
|
encode_real(aabb.size.z, &buf[sizeof(real_t) * 5]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 6 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2017-01-11 04:52:51 +01:00
|
|
|
case Variant::BASIS: {
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
Basis val = p_variant;
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
2020-03-17 04:11:41 +01:00
|
|
|
memcpy(&buf[(i * 3 + j) * sizeof(real_t)], &val.elements[i][j], sizeof(real_t));
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 9 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2021-04-28 09:36:08 +02:00
|
|
|
case Variant::TRANSFORM3D: {
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2020-10-17 07:08:21 +02:00
|
|
|
Transform3D val = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
for (int j = 0; j < 3; j++) {
|
2020-03-17 04:11:41 +01:00
|
|
|
memcpy(&buf[(i * 3 + j) * sizeof(real_t)], &val.basis.elements[i][j], sizeof(real_t));
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(val.origin.x, &buf[sizeof(real_t) * 9]);
|
|
|
|
encode_real(val.origin.y, &buf[sizeof(real_t) * 10]);
|
|
|
|
encode_real(val.origin.z, &buf[sizeof(real_t) * 11]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 12 * sizeof(real_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
|
|
|
|
|
|
|
// misc types
|
|
|
|
case Variant::COLOR: {
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
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]);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += 4 * 4; // Colors should always be in single-precision.
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2016-03-09 00:00:52 +01:00
|
|
|
} break;
|
2020-11-09 14:53:05 +01:00
|
|
|
case Variant::RID: {
|
2020-02-19 20:27:19 +01:00
|
|
|
} break;
|
|
|
|
case Variant::CALLABLE: {
|
|
|
|
} break;
|
|
|
|
case Variant::SIGNAL: {
|
2017-08-14 16:58:10 +02:00
|
|
|
} break;
|
2014-02-10 02:10:30 +01:00
|
|
|
case Variant::OBJECT: {
|
2019-03-28 09:40:31 +01:00
|
|
|
if (p_full_objects) {
|
2017-08-18 15:59:31 +02:00
|
|
|
Object *obj = p_variant;
|
|
|
|
if (!obj) {
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(0, buf);
|
|
|
|
}
|
2017-10-08 20:13:46 +02:00
|
|
|
r_len += 4;
|
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
} else {
|
|
|
|
_encode_string(obj->get_class(), buf, r_len);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
List<PropertyInfo> props;
|
|
|
|
obj->get_property_list(&props);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
int pc = 0;
|
2021-07-24 15:46:25 +02:00
|
|
|
for (const PropertyInfo &E : props) {
|
2021-07-16 05:45:57 +02:00
|
|
|
if (!(E.usage & PROPERTY_USAGE_STORAGE)) {
|
2017-08-18 15:59:31 +02:00
|
|
|
continue;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-18 15:59:31 +02:00
|
|
|
pc++;
|
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
if (buf) {
|
|
|
|
encode_uint32(pc, buf);
|
|
|
|
buf += 4;
|
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
r_len += 4;
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2021-07-24 15:46:25 +02:00
|
|
|
for (const PropertyInfo &E : props) {
|
2021-07-16 05:45:57 +02:00
|
|
|
if (!(E.usage & PROPERTY_USAGE_STORAGE)) {
|
2017-08-18 15:59:31 +02:00
|
|
|
continue;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2021-07-16 05:45:57 +02:00
|
|
|
_encode_string(E.name, buf, r_len);
|
2017-08-14 16:58:10 +02:00
|
|
|
|
2017-08-18 15:59:31 +02:00
|
|
|
int len;
|
2021-07-30 15:43:01 +02:00
|
|
|
Error err = encode_variant(obj->get(E.name), buf, len, p_full_objects, p_depth + 1);
|
|
|
|
ERR_FAIL_COND_V(err, err);
|
2017-08-18 15:59:31 +02:00
|
|
|
ERR_FAIL_COND_V(len % 4, ERR_BUG);
|
|
|
|
r_len += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2017-08-18 15:59:31 +02:00
|
|
|
buf += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2017-08-18 15:59:31 +02:00
|
|
|
}
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
2019-03-28 09:40:31 +01:00
|
|
|
} else {
|
|
|
|
if (buf) {
|
2020-02-13 20:03:10 +01:00
|
|
|
Object *obj = p_variant.get_validated_object();
|
2020-02-12 18:24:06 +01:00
|
|
|
ObjectID id;
|
2020-02-13 20:03:10 +01:00
|
|
|
if (obj) {
|
2019-03-28 09:40:31 +01:00
|
|
|
id = obj->get_instance_id();
|
|
|
|
}
|
|
|
|
|
|
|
|
encode_uint64(id, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 8;
|
2017-08-14 16:58:10 +02:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
|
|
|
case Variant::DICTIONARY: {
|
|
|
|
Dictionary d = p_variant;
|
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(uint32_t(d.size()), buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
List<Variant> keys;
|
|
|
|
d.get_key_list(&keys);
|
|
|
|
|
2021-07-24 15:46:25 +02:00
|
|
|
for (const Variant &E : keys) {
|
2014-02-10 02:10:30 +01:00
|
|
|
/*
|
|
|
|
CharString utf8 = E->->utf8();
|
|
|
|
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(utf8.length()+1,buf);
|
|
|
|
buf+=4;
|
2021-04-27 16:19:21 +02:00
|
|
|
memcpy(buf,utf8.get_data(),utf8.length()+1);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
r_len+=4+utf8.length()+1;
|
|
|
|
while (r_len%4)
|
|
|
|
r_len++; //pad
|
|
|
|
*/
|
|
|
|
int len;
|
2021-07-30 15:43:01 +02:00
|
|
|
Error err = encode_variant(E, buf, len, p_full_objects, p_depth + 1);
|
|
|
|
ERR_FAIL_COND_V(err, err);
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len % 4, ERR_BUG);
|
|
|
|
r_len += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2014-02-10 02:10:30 +01:00
|
|
|
buf += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2021-07-16 05:45:57 +02:00
|
|
|
Variant *v = d.getptr(E);
|
2018-01-24 19:24:18 +01:00
|
|
|
ERR_FAIL_COND_V(!v, ERR_BUG);
|
2021-07-30 15:43:01 +02:00
|
|
|
err = encode_variant(*v, buf, len, p_full_objects, p_depth + 1);
|
|
|
|
ERR_FAIL_COND_V(err, err);
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len % 4, ERR_BUG);
|
|
|
|
r_len += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2014-02-10 02:10:30 +01:00
|
|
|
buf += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::ARRAY: {
|
|
|
|
Array v = p_variant;
|
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(uint32_t(v.size()), buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < v.size(); i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
int len;
|
2021-07-30 15:43:01 +02:00
|
|
|
Error err = encode_variant(v.get(i), buf, len, p_full_objects, p_depth + 1);
|
|
|
|
ERR_FAIL_COND_V(err, err);
|
2017-03-05 16:44:50 +01:00
|
|
|
ERR_FAIL_COND_V(len % 4, ERR_BUG);
|
|
|
|
r_len += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += len;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
} break;
|
|
|
|
// arrays
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_BYTE_ARRAY: {
|
|
|
|
Vector<uint8_t> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int datalen = data.size();
|
|
|
|
int datasize = sizeof(uint8_t);
|
2016-03-09 00:00:52 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(datalen, buf);
|
|
|
|
buf += 4;
|
2020-02-17 22:06:54 +01:00
|
|
|
const uint8_t *r = data.ptr();
|
2021-04-27 16:19:21 +02:00
|
|
|
memcpy(buf, &r[0], datalen * datasize);
|
2019-05-19 19:09:16 +02:00
|
|
|
buf += datalen * datasize;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 + datalen * datasize;
|
2019-05-19 19:09:16 +02:00
|
|
|
while (r_len % 4) {
|
2014-02-10 02:10:30 +01:00
|
|
|
r_len++;
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2019-05-19 19:09:16 +02:00
|
|
|
*(buf++) = 0;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2019-05-19 19:09:16 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::PACKED_INT32_ARRAY: {
|
|
|
|
Vector<int32_t> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int datalen = data.size();
|
|
|
|
int datasize = sizeof(int32_t);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(datalen, buf);
|
|
|
|
buf += 4;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
const int32_t *r = data.ptr();
|
2020-05-14 16:41:43 +02:00
|
|
|
for (int32_t i = 0; i < datalen; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(r[i], &buf[i * datasize]);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 + datalen * datasize;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
case Variant::PACKED_INT64_ARRAY: {
|
|
|
|
Vector<int64_t> data = p_variant;
|
|
|
|
int datalen = data.size();
|
|
|
|
int datasize = sizeof(int64_t);
|
|
|
|
|
|
|
|
if (buf) {
|
2021-08-02 13:34:06 +02:00
|
|
|
encode_uint32(datalen, buf);
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
buf += 4;
|
|
|
|
const int64_t *r = data.ptr();
|
2020-05-14 16:41:43 +02:00
|
|
|
for (int64_t i = 0; i < datalen; i++) {
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
encode_uint64(r[i], &buf[i * datasize]);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 4 + datalen * datasize;
|
|
|
|
|
|
|
|
} break;
|
|
|
|
case Variant::PACKED_FLOAT32_ARRAY: {
|
|
|
|
Vector<float> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int datalen = data.size();
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
int datasize = sizeof(float);
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(datalen, buf);
|
|
|
|
buf += 4;
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
const float *r = data.ptr();
|
2020-05-14 16:41:43 +02:00
|
|
|
for (int i = 0; i < datalen; i++) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_float(r[i], &buf[i * datasize]);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 + datalen * datasize;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
} break;
|
|
|
|
case Variant::PACKED_FLOAT64_ARRAY: {
|
|
|
|
Vector<double> data = p_variant;
|
|
|
|
int datalen = data.size();
|
|
|
|
int datasize = sizeof(double);
|
|
|
|
|
|
|
|
if (buf) {
|
|
|
|
encode_uint32(datalen, buf);
|
|
|
|
buf += 4;
|
|
|
|
const double *r = data.ptr();
|
2020-05-14 16:41:43 +02:00
|
|
|
for (int i = 0; i < datalen; i++) {
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
encode_double(r[i], &buf[i * datasize]);
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 19:20:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
r_len += 4 + datalen * datasize;
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_STRING_ARRAY: {
|
|
|
|
Vector<String> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = data.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(len, buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < len; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
CharString utf8 = data.get(i).utf8();
|
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(utf8.length() + 1, buf);
|
|
|
|
buf += 4;
|
2021-04-27 16:19:21 +02:00
|
|
|
memcpy(buf, utf8.get_data(), utf8.length() + 1);
|
2017-03-05 16:44:50 +01:00
|
|
|
buf += utf8.length() + 1;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 + utf8.length() + 1;
|
|
|
|
while (r_len % 4) {
|
2014-02-10 02:10:30 +01:00
|
|
|
r_len++; //pad
|
2020-05-14 16:41:43 +02:00
|
|
|
if (buf) {
|
2018-07-08 15:11:41 +02:00
|
|
|
*(buf++) = 0;
|
2020-05-14 16:41:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-10 10:37:04 +02:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_VECTOR2_ARRAY: {
|
|
|
|
Vector<Vector2> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = data.size();
|
2013-04-10 10:37:04 +02:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(len, buf);
|
|
|
|
buf += 4;
|
2013-04-10 10:37:04 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < len; i++) {
|
2013-04-10 10:37:04 +02:00
|
|
|
Vector2 v = data.get(i);
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(v.x, &buf[0]);
|
|
|
|
encode_real(v.y, &buf[sizeof(real_t)]);
|
|
|
|
buf += sizeof(real_t) * 2;
|
2013-04-10 10:37:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += sizeof(real_t) * 2 * len;
|
2013-04-10 10:37:04 +02:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_VECTOR3_ARRAY: {
|
|
|
|
Vector<Vector3> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = data.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(len, buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < len; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
Vector3 v = data.get(i);
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
encode_real(v.x, &buf[0]);
|
|
|
|
encode_real(v.y, &buf[sizeof(real_t)]);
|
|
|
|
encode_real(v.z, &buf[sizeof(real_t) * 2]);
|
|
|
|
buf += sizeof(real_t) * 3;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-17 04:11:41 +01:00
|
|
|
r_len += sizeof(real_t) * 3 * len;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2020-02-17 22:06:54 +01:00
|
|
|
case Variant::PACKED_COLOR_ARRAY: {
|
|
|
|
Vector<Color> data = p_variant;
|
2017-03-05 16:44:50 +01:00
|
|
|
int len = data.size();
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_uint32(len, buf);
|
|
|
|
buf += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (buf) {
|
2017-03-05 16:44:50 +01:00
|
|
|
for (int i = 0; i < len; i++) {
|
2014-02-10 02:10:30 +01:00
|
|
|
Color c = data.get(i);
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
encode_float(c.r, &buf[0]);
|
|
|
|
encode_float(c.g, &buf[4]);
|
|
|
|
encode_float(c.b, &buf[8]);
|
|
|
|
encode_float(c.a, &buf[12]);
|
2020-03-17 04:11:41 +01:00
|
|
|
buf += 4 * 4; // Colors should always be in single-precision.
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
r_len += 4 * 4 * len;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
} break;
|
2019-04-09 17:08:36 +02:00
|
|
|
default: {
|
|
|
|
ERR_FAIL_V(ERR_BUG);
|
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|