godotengine
/
godot
mirror of https://github.com/godotengine/godot
1
0
Fork 0
Code

Merge f1039eba77 into 15ff450680

This commit is contained in:
Lukas Tenbrink 2025-02-28 01:35:55 +01:00 committed by GitHub
parent 15ff450680 f1039eba77
commit a6266d79ee
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 140 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

706
core/variant/variant.cpp
View File

@ -186,354 +186,21 @@ Variant::Type Variant::get_type_by_name(const String &p_type_name) {
return (ptr == nullptr) ? VARIANT_MAX : *ptr; return (ptr == nullptr) ? VARIANT_MAX : *ptr;
} }
bool Variant::can_convert(Variant::Type p_type_from, Variant::Type p_type_to) { template <size_t N>
if (p_type_from == p_type_to) { constexpr bool _contains(const Variant::Type (&p_types)[N], Variant::Type p_type) {
return true; for (const Variant::Type type : p_types) {
} if (type == p_type) {
if (p_type_to == NIL) { //nil can convert to anything return true;
return true;
}
if (p_type_from == NIL) {
return (p_type_to == OBJECT);
}
const Type *valid_types = nullptr;
const Type *invalid_types = nullptr;
switch (p_type_to) {
case BOOL: {
static const Type valid[] = {
INT,
FLOAT,
STRING,
NIL,
};
valid_types = valid;
} break;
case INT: {
static const Type valid[] = {
BOOL,
FLOAT,
STRING,
NIL,
};
valid_types = valid;
} break;
case FLOAT: {
static const Type valid[] = {
BOOL,
INT,
STRING,
NIL,
};
valid_types = valid;
} break;
case STRING: {
static const Type invalid[] = {
OBJECT,
NIL
};
invalid_types = invalid;
} break;
case VECTOR2: {
static const Type valid[] = {
VECTOR2I,
NIL,
};
valid_types = valid;
} break;
case VECTOR2I: {
static const Type valid[] = {
VECTOR2,
NIL,
};
valid_types = valid;
} break;
case RECT2: {
static const Type valid[] = {
RECT2I,
NIL,
};
valid_types = valid;
} break;
case RECT2I: {
static const Type valid[] = {
RECT2,
NIL,
};
valid_types = valid;
} break;
case TRANSFORM2D: {
static const Type valid[] = {
TRANSFORM3D,
NIL
};
valid_types = valid;
} break;
case VECTOR3: {
static const Type valid[] = {
VECTOR3I,
NIL,
};
valid_types = valid;
} break;
case VECTOR3I: {
static const Type valid[] = {
VECTOR3,
NIL,
};
valid_types = valid;
} break;
case VECTOR4: {
static const Type valid[] = {
VECTOR4I,
NIL,
};
valid_types = valid;
} break;
case VECTOR4I: {
static const Type valid[] = {
VECTOR4,
NIL,
};
valid_types = valid;
} break;
case QUATERNION: {
static const Type valid[] = {
BASIS,
NIL
};
valid_types = valid;
} break;
case BASIS: {
static const Type valid[] = {
QUATERNION,
NIL
};
valid_types = valid;
} break;
case TRANSFORM3D: {
static const Type valid[] = {
TRANSFORM2D,
QUATERNION,
BASIS,
PROJECTION,
NIL
};
valid_types = valid;
} break;
case PROJECTION: {
static const Type valid[] = {
TRANSFORM3D,
NIL
};
valid_types = valid;
} break;
case COLOR: {
static const Type valid[] = {
STRING,
INT,
NIL,
};
valid_types = valid;
} break;
case RID: {
static const Type valid[] = {
OBJECT,
NIL
};
valid_types = valid;
} break;
case OBJECT: {
static const Type valid[] = {
NIL
};
valid_types = valid;
} break;
case STRING_NAME: {
static const Type valid[] = {
STRING,
NIL
};
valid_types = valid;
} break;
case NODE_PATH: {
static const Type valid[] = {
STRING,
NIL
};
valid_types = valid;
} break;
case ARRAY: {
static const Type valid[] = {
PACKED_BYTE_ARRAY,
PACKED_INT32_ARRAY,
PACKED_INT64_ARRAY,
PACKED_FLOAT32_ARRAY,
PACKED_FLOAT64_ARRAY,
PACKED_STRING_ARRAY,
PACKED_COLOR_ARRAY,
PACKED_VECTOR2_ARRAY,
PACKED_VECTOR3_ARRAY,
PACKED_VECTOR4_ARRAY,
NIL
};
valid_types = valid;
} break;
// arrays
case PACKED_BYTE_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_INT32_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_INT64_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_FLOAT32_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_FLOAT64_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_STRING_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_VECTOR2_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_VECTOR3_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_COLOR_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
case PACKED_VECTOR4_ARRAY: {
static const Type valid[] = {
ARRAY,
NIL
};
valid_types = valid;
} break;
default: {
} }
} }
if (valid_types) {
int i = 0;
while (valid_types[i] != NIL) {
if (p_type_from == valid_types[i]) {
return true;
}
i++;
}
} else if (invalid_types) {
int i = 0;
while (invalid_types[i] != NIL) {
if (p_type_from == invalid_types[i]) {
return false;
}
i++;
}
return true;
}
return false; return false;
} }
bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type_to) { bool Variant::can_convert(Type p_type_from, Type p_type_to, bool p_strict) {
if (p_type_from == p_type_to) { if (p_type_from == p_type_to) {
return true; return true;
} }
if (p_type_to == NIL) { //nil can convert to anything if (p_type_to == NIL) { // Anything can convert to NIL.
return true; return true;
} }
@ -541,215 +208,155 @@ bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type
return (p_type_to == OBJECT); return (p_type_to == OBJECT);
} }
const Type *valid_types = nullptr; // clang-format off
switch (p_type_to) { switch (p_type_to) {
case BOOL: { case BOOL: {
static const Type valid[] = { if (p_strict) {
return _contains({
INT,
FLOAT,
}, p_type_from);
}
return _contains({
INT, INT,
FLOAT, FLOAT,
//STRING, STRING,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case INT: { case INT: {
static const Type valid[] = { if (p_strict) {
return _contains({
BOOL,
FLOAT,
}, p_type_from);
}
return _contains({
BOOL, BOOL,
FLOAT, FLOAT,
//STRING, STRING,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case FLOAT: { case FLOAT: {
static const Type valid[] = { if (p_strict) {
return _contains({
BOOL,
INT,
}, p_type_from);
}
return _contains({
BOOL, BOOL,
INT, INT,
//STRING, STRING,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case STRING: { case STRING: {
static const Type valid[] = { if (p_strict) {
NODE_PATH, return _contains({
STRING_NAME, NODE_PATH,
NIL STRING_NAME,
}; }, p_type_from);
}
valid_types = valid; return !_contains({
} break; OBJECT,
}, p_type_from);
}
case VECTOR2: { case VECTOR2: {
static const Type valid[] = { return _contains({
VECTOR2I, VECTOR2I,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case VECTOR2I: { case VECTOR2I: {
static const Type valid[] = { return _contains({
VECTOR2, VECTOR2,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case RECT2: { case RECT2: {
static const Type valid[] = { return _contains({
RECT2I, RECT2I,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case RECT2I: { case RECT2I: {
static const Type valid[] = { return _contains({
RECT2, RECT2,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case TRANSFORM2D: { case TRANSFORM2D: {
static const Type valid[] = { return _contains({
TRANSFORM3D, TRANSFORM3D,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case VECTOR3: { case VECTOR3: {
static const Type valid[] = { return _contains({
VECTOR3I, VECTOR3I,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case VECTOR3I: { case VECTOR3I: {
static const Type valid[] = { return _contains({
VECTOR3, VECTOR3,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case VECTOR4: { case VECTOR4: {
static const Type valid[] = { return _contains({
VECTOR4I, VECTOR4I,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case VECTOR4I: { case VECTOR4I: {
static const Type valid[] = { return _contains({
VECTOR4, VECTOR4,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case QUATERNION: { case QUATERNION: {
static const Type valid[] = { return _contains({
BASIS, BASIS,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case BASIS: { case BASIS: {
static const Type valid[] = { return _contains({
QUATERNION, QUATERNION,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case TRANSFORM3D: { case TRANSFORM3D: {
static const Type valid[] = { return _contains({
TRANSFORM2D, TRANSFORM2D,
QUATERNION, QUATERNION,
BASIS, BASIS,
PROJECTION, PROJECTION,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PROJECTION: { case PROJECTION: {
static const Type valid[] = { return _contains({
TRANSFORM3D, TRANSFORM3D,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case COLOR: { case COLOR: {
static const Type valid[] = { return _contains({
STRING, STRING,
INT, INT,
NIL, }, p_type_from);
}; }
valid_types = valid;
} break;
case RID: { case RID: {
static const Type valid[] = { return _contains({
OBJECT, OBJECT,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case OBJECT: { case OBJECT: {
static const Type valid[] = { return false;
NIL }
};
valid_types = valid;
} break;
case STRING_NAME: { case STRING_NAME: {
static const Type valid[] = { return _contains({
STRING, STRING,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case NODE_PATH: { case NODE_PATH: {
static const Type valid[] = { return _contains({
STRING, STRING,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case ARRAY: { case ARRAY: {
static const Type valid[] = { return _contains({
PACKED_BYTE_ARRAY, PACKED_BYTE_ARRAY,
PACKED_INT32_ARRAY, PACKED_INT32_ARRAY,
PACKED_INT64_ARRAY, PACKED_INT64_ARRAY,
@ -760,105 +367,64 @@ bool Variant::can_convert_strict(Variant::Type p_type_from, Variant::Type p_type
PACKED_VECTOR2_ARRAY, PACKED_VECTOR2_ARRAY,
PACKED_VECTOR3_ARRAY, PACKED_VECTOR3_ARRAY,
PACKED_VECTOR4_ARRAY, PACKED_VECTOR4_ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
// arrays // arrays
case PACKED_BYTE_ARRAY: { case PACKED_BYTE_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_INT32_ARRAY: { case PACKED_INT32_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_INT64_ARRAY: { case PACKED_INT64_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_FLOAT32_ARRAY: { case PACKED_FLOAT32_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_FLOAT64_ARRAY: { case PACKED_FLOAT64_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_STRING_ARRAY: { case PACKED_STRING_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_VECTOR2_ARRAY: { case PACKED_VECTOR2_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_VECTOR3_ARRAY: { case PACKED_VECTOR3_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_COLOR_ARRAY: { case PACKED_COLOR_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
case PACKED_VECTOR4_ARRAY: { case PACKED_VECTOR4_ARRAY: {
static const Type valid[] = { return _contains({
ARRAY, ARRAY,
NIL }, p_type_from);
}; }
valid_types = valid;
} break;
default: { default: {
return false;
} }
} }
// clang-format on
if (valid_types) {
int i = 0;
while (valid_types[i] != NIL) {
if (p_type_from == valid_types[i]) {
return true;
}
i++;
}
}
return false;
} }
bool Variant::operator==(const Variant &p_variant) const { bool Variant::operator==(const Variant &p_variant) const {

6
core/variant/variant.h
View File

@ -393,8 +393,10 @@ public:
} }
static String get_type_name(Variant::Type p_type); static String get_type_name(Variant::Type p_type);
static Variant::Type get_type_by_name(const String &p_type_name); static Variant::Type get_type_by_name(const String &p_type_name);
static bool can_convert(Type p_type_from, Type p_type_to); static bool can_convert(Type p_type_from, Type p_type_to, bool p_strict = false);
static bool can_convert_strict(Type p_type_from, Type p_type_to); static bool can_convert_strict(Type p_type_from, Type p_type_to) {
return can_convert(p_type_from, p_type_to, true);
}
static bool is_type_shared(Variant::Type p_type); static bool is_type_shared(Variant::Type p_type);
bool is_ref_counted() const; bool is_ref_counted() const;