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.

1 files changed, 89 insertions, 22 deletions

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);