Merge pull request #36515 from reduz/packed-array-64-bits

Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT. 

3 files changed, 197 insertions, 41 deletions

diff --git a/core/io/json.cpp b/core/io/json.cpp
index 08a147032f..3a0edceb81 100644
--- a/core/io/json.cpp
+++ b/core/io/json.cpp
@@ -70,9 +70,11 @@ String JSON::_print_var(const Variant &p_var, const String &p_indent, int p_cur_
 		case Variant::NIL: return "null";
 		case Variant::BOOL: return p_var.operator bool() ? "true" : "false";
 		case Variant::INT: return itos(p_var);
-		case Variant::REAL: return rtos(p_var);
-		case Variant::PACKED_INT_ARRAY:
-		case Variant::PACKED_REAL_ARRAY:
+		case Variant::FLOAT: return rtos(p_var);
+		case Variant::PACKED_INT32_ARRAY:
+		case Variant::PACKED_INT64_ARRAY:
+		case Variant::PACKED_FLOAT32_ARRAY:
+		case Variant::PACKED_FLOAT64_ARRAY:
 		case Variant::PACKED_STRING_ARRAY:
 		case Variant::ARRAY: {
 
diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp
index e97c26e05d..0b815b2c7b 100644
--- a/core/io/marshalls.cpp
+++ b/core/io/marshalls.cpp
@@ -147,7 +147,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			}
 
 		} break;
-		case Variant::REAL: {
+		case Variant::FLOAT: {
 
 			if (type & ENCODE_FLAG_64) {
 				ERR_FAIL_COND_V(len < 8, ERR_INVALID_DATA);
@@ -621,7 +621,7 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			}
 
 		} break;
-		case Variant::PACKED_INT_ARRAY: {
+		case Variant::PACKED_INT32_ARRAY: {
 
 			ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
 			int32_t count = decode_uint32(buf);
@@ -630,12 +630,12 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			ERR_FAIL_MUL_OF(count, 4, ERR_INVALID_DATA);
 			ERR_FAIL_COND_V(count < 0 || count * 4 > len, ERR_INVALID_DATA);
 
-			Vector<int> data;
+			Vector<int32_t> data;
 
 			if (count) {
 				//const int*rbuf=(const int*)buf;
 				data.resize(count);
-				int *w = data.ptrw();
+				int32_t *w = data.ptrw();
 				for (int32_t i = 0; i < count; i++) {
 
 					w[i] = decode_uint32(&buf[i * 4]);
@@ -643,11 +643,37 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			}
 			r_variant = Variant(data);
 			if (r_len) {
-				(*r_len) += 4 + count * sizeof(int);
+				(*r_len) += 4 + count * sizeof(int32_t);
 			}
 
 		} break;
-		case Variant::PACKED_REAL_ARRAY: {
+		case Variant::PACKED_INT64_ARRAY: {
+
+			ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
+			int64_t count = decode_uint64(buf);
+			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: {
 
 			ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
 			int32_t count = decode_uint32(buf);
@@ -674,6 +700,33 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int
 			}
 
 		} break;
+		case Variant::PACKED_FLOAT64_ARRAY: {
+
+			ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
+			int64_t count = decode_uint64(buf);
+			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) {
+				//const double*rbuf=(const double*)buf;
+				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);
+			}
+
+		} break;
 		case Variant::PACKED_STRING_ARRAY: {
 
 			ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
@@ -851,7 +904,7 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
 				flags |= ENCODE_FLAG_64;
 			}
 		} break;
-		case Variant::REAL: {
+		case Variant::FLOAT: {
 
 			double d = p_variant;
 			float f = d;
@@ -918,7 +971,7 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
 				r_len += 4;
 			}
 		} break;
-		case Variant::REAL: {
+		case Variant::FLOAT: {
 
 			if (flags & ENCODE_FLAG_64) {
 				if (buf) {
@@ -1333,33 +1386,50 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
 			}
 
 		} break;
-		case Variant::PACKED_INT_ARRAY: {
+		case Variant::PACKED_INT32_ARRAY: {
 
-			Vector<int> data = p_variant;
+			Vector<int32_t> data = p_variant;
 			int datalen = data.size();
 			int datasize = sizeof(int32_t);
 
 			if (buf) {
 				encode_uint32(datalen, buf);
 				buf += 4;
-				const int *r = data.ptr();
-				for (int i = 0; i < datalen; i++)
+				const int32_t *r = data.ptr();
+				for (int32_t i = 0; i < datalen; i++)
 					encode_uint32(r[i], &buf[i * datasize]);
 			}
 
 			r_len += 4 + datalen * datasize;
 
 		} break;
-		case Variant::PACKED_REAL_ARRAY: {
+		case Variant::PACKED_INT64_ARRAY: {
+
+			Vector<int64_t> data = p_variant;
+			int datalen = data.size();
+			int datasize = sizeof(int64_t);
+
+			if (buf) {
+				encode_uint64(datalen, buf);
+				buf += 4;
+				const int64_t *r = data.ptr();
+				for (int64_t i = 0; i < datalen; i++)
+					encode_uint64(r[i], &buf[i * datasize]);
+			}
+
+			r_len += 4 + datalen * datasize;
+
+		} break;
+		case Variant::PACKED_FLOAT32_ARRAY: {
 
-			Vector<real_t> data = p_variant;
+			Vector<float> data = p_variant;
 			int datalen = data.size();
-			int datasize = sizeof(real_t);
+			int datasize = sizeof(float);
 
 			if (buf) {
 				encode_uint32(datalen, buf);
 				buf += 4;
-				const real_t *r = data.ptr();
+				const float *r = data.ptr();
 				for (int i = 0; i < datalen; i++)
 					encode_float(r[i], &buf[i * datasize]);
 			}
@@ -1367,6 +1437,23 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len, bo
 			r_len += 4 + datalen * datasize;
 
 		} 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();
+				for (int i = 0; i < datalen; i++)
+					encode_double(r[i], &buf[i * datasize]);
+			}
+
+			r_len += 4 + datalen * datasize;
+
+		} break;
 		case Variant::PACKED_STRING_ARRAY: {
 
 			Vector<String> data = p_variant;
diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index 518323c5c4..8c343a0f43 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -46,7 +46,7 @@ enum {
 	VARIANT_NIL = 1,
 	VARIANT_BOOL = 2,
 	VARIANT_INT = 3,
-	VARIANT_REAL = 4,
+	VARIANT_FLOAT = 4,
 	VARIANT_STRING = 5,
 	VARIANT_VECTOR2 = 10,
 	VARIANT_RECT2 = 11,
@@ -65,8 +65,8 @@ enum {
 	VARIANT_DICTIONARY = 26,
 	VARIANT_ARRAY = 30,
 	VARIANT_RAW_ARRAY = 31,
-	VARIANT_INT_ARRAY = 32,
-	VARIANT_REAL_ARRAY = 33,
+	VARIANT_INT32_ARRAY = 32,
+	VARIANT_FLOAT32_ARRAY = 33,
 	VARIANT_STRING_ARRAY = 34,
 	VARIANT_VECTOR3_ARRAY = 35,
 	VARIANT_COLOR_ARRAY = 36,
@@ -79,6 +79,8 @@ enum {
 	VARIANT_VECTOR2I = 45,
 	VARIANT_RECT2I = 46,
 	VARIANT_VECTOR3I = 47,
+	VARIANT_INT64_ARRAY = 48,
+	VARIANT_FLOAT64_ARRAY = 49,
 	OBJECT_EMPTY = 0,
 	OBJECT_EXTERNAL_RESOURCE = 1,
 	OBJECT_INTERNAL_RESOURCE = 2,
@@ -142,7 +144,7 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
 
 			r_v = int64_t(f->get_64());
 		} break;
-		case VARIANT_REAL: {
+		case VARIANT_FLOAT: {
 
 			r_v = f->get_real();
 		} break;
@@ -452,14 +454,14 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
 			r_v = array;
 
 		} break;
-		case VARIANT_INT_ARRAY: {
+		case VARIANT_INT32_ARRAY: {
 
 			uint32_t len = f->get_32();
 
-			Vector<int> array;
+			Vector<int32_t> array;
 			array.resize(len);
-			int *w = array.ptrw();
-			f->get_buffer((uint8_t *)w, len * 4);
+			int32_t *w = array.ptrw();
+			f->get_buffer((uint8_t *)w, len * sizeof(int32_t));
 #ifdef BIG_ENDIAN_ENABLED
 			{
 				uint32_t *ptr = (uint32_t *)w.ptr();
@@ -473,14 +475,35 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
 
 			r_v = array;
 		} break;
-		case VARIANT_REAL_ARRAY: {
+		case VARIANT_INT64_ARRAY: {
 
 			uint32_t len = f->get_32();
 
-			Vector<real_t> array;
+			Vector<int64_t> array;
 			array.resize(len);
-			real_t *w = array.ptrw();
-			f->get_buffer((uint8_t *)w, len * sizeof(real_t));
+			int64_t *w = array.ptrw();
+			f->get_buffer((uint8_t *)w, len * sizeof(int64_t));
+#ifdef BIG_ENDIAN_ENABLED
+			{
+				uint64_t *ptr = (uint64_t *)w.ptr();
+				for (int i = 0; i < len; i++) {
+
+					ptr[i] = BSWAP64(ptr[i]);
+				}
+			}
+
+#endif
+
+			r_v = array;
+		} break;
+		case VARIANT_FLOAT32_ARRAY: {
+
+			uint32_t len = f->get_32();
+
+			Vector<float> array;
+			array.resize(len);
+			float *w = array.ptrw();
+			f->get_buffer((uint8_t *)w, len * sizeof(float));
 #ifdef BIG_ENDIAN_ENABLED
 			{
 				uint32_t *ptr = (uint32_t *)w.ptr();
@@ -494,6 +517,27 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
 
 			r_v = array;
 		} break;
+		case VARIANT_FLOAT64_ARRAY: {
+
+			uint32_t len = f->get_32();
+
+			Vector<double> array;
+			array.resize(len);
+			double *w = array.ptrw();
+			f->get_buffer((uint8_t *)w, len * sizeof(double));
+#ifdef BIG_ENDIAN_ENABLED
+			{
+				uint64_t *ptr = (uint64_t *)w.ptr();
+				for (int i = 0; i < len; i++) {
+
+					ptr[i] = BSWAP64(ptr[i]);
+				}
+			}
+
+#endif
+
+			r_v = array;
+		} break;
 		case VARIANT_STRING_ARRAY: {
 
 			uint32_t len = f->get_32();
@@ -1293,7 +1337,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
 			}
 
 		} break;
-		case Variant::REAL: {
+		case Variant::FLOAT: {
 
 			double d = p_property;
 			float fl = d;
@@ -1302,7 +1346,7 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
 				f->store_double(d);
 			} else {
 
-				f->store_32(VARIANT_REAL);
+				f->store_32(VARIANT_FLOAT);
 				f->store_real(fl);
 			}
 
@@ -1573,29 +1617,52 @@ void ResourceFormatSaverBinaryInstance::write_variant(FileAccess *f, const Varia
 			_pad_buffer(f, len);
 
 		} break;
-		case Variant::PACKED_INT_ARRAY: {
+		case Variant::PACKED_INT32_ARRAY: {
 
-			f->store_32(VARIANT_INT_ARRAY);
-			Vector<int> arr = p_property;
+			f->store_32(VARIANT_INT32_ARRAY);
+			Vector<int32_t> arr = p_property;
 			int len = arr.size();
 			f->store_32(len);
-			const int *r = arr.ptr();
+			const int32_t *r = arr.ptr();
 			for (int i = 0; i < len; i++)
 				f->store_32(r[i]);
 
 		} break;
-		case Variant::PACKED_REAL_ARRAY: {
+		case Variant::PACKED_INT64_ARRAY: {
 
-			f->store_32(VARIANT_REAL_ARRAY);
-			Vector<real_t> arr = p_property;
+			f->store_32(VARIANT_INT64_ARRAY);
+			Vector<int64_t> arr = p_property;
 			int len = arr.size();
 			f->store_32(len);
-			const real_t *r = arr.ptr();
+			const int64_t *r = arr.ptr();
+			for (int i = 0; i < len; i++)
+				f->store_64(r[i]);
+
+		} break;
+		case Variant::PACKED_FLOAT32_ARRAY: {
+
+			f->store_32(VARIANT_FLOAT32_ARRAY);
+			Vector<float> arr = p_property;
+			int len = arr.size();
+			f->store_32(len);
+			const float *r = arr.ptr();
 			for (int i = 0; i < len; i++) {
 				f->store_real(r[i]);
 			}
 
 		} break;
+		case Variant::PACKED_FLOAT64_ARRAY: {
+
+			f->store_32(VARIANT_FLOAT64_ARRAY);
+			Vector<double> arr = p_property;
+			int len = arr.size();
+			f->store_32(len);
+			const double *r = arr.ptr();
+			for (int i = 0; i < len; i++) {
+				f->store_double(r[i]);
+			}
+
+		} break;
 		case Variant::PACKED_STRING_ARRAY: {
 
 			f->store_32(VARIANT_STRING_ARRAY);