godotengine/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2026-01-03 18:11:19 +03:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
- 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.
This commit is contained in:
Juan Linietsky
2020-02-24 15:20:53 -03:00
committed by Juan Linietsky
parent c19488bd89
commit 33b5c57199
201 changed files with 2501 additions and 1782 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
core/io/resource_format_binary.cpp
View File

@@ -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();
@@ -490,6 +513,27 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) {
}
}
#endif
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;
@@ -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,28 +1617,51 @@ 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: {