godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/core/variant/variant.h

702 lines
25 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* variant.h */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Update copyright statements to 2021 Happy new year to the wonderful Godot community! 2020 has been a tough year for most of us personally, but a good year for Godot development nonetheless with a huge amount of work done towards Godot 4.0 and great improvements backported to the long-lived 3.2 branch. We've had close to 400 contributors to engine code this year, authoring near 7,000 commit! (And that's only for the `master` branch and for the engine code, there's a lot more when counting docs, demos and other first-party repos.) Here's to a great year 2021 for all Godot users 🎆
2021-01-01 19:13:46 +00:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00: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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#ifndef VARIANT_H
#define VARIANT_H
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/io/ip_address.h"
#include "core/math/aabb.h"
[Core] Rename Matrix3 file to Basis The code already referred to "Basis", it's just the file name that was different for some reason.
2019-02-09 05:24:02 +00:00
#include "core/math/basis.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 22:33:38 +00:00
#include "core/math/color.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/math/face3.h"
#include "core/math/plane.h"
#include "core/math/quat.h"
#include "core/math/transform_2d.h"
Rename files and the exposed name for Transform3D
2021-02-27 04:26:56 +00:00
#include "core/math/transform_3d.h"
Make core/ includes absolute, remove subfolders from include path This allows more consistency in the manner we include core headers, where previously there would be a mix of absolute, relative and include path-dependent includes.
2018-09-11 16:13:45 +00:00
#include "core/math/vector3.h"
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
#include "core/math/vector3i.h"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 22:33:38 +00:00
#include "core/object/object_id.h"
#include "core/string/node_path.h"
#include "core/string/ustring.h"
#include "core/templates/rid.h"
#include "core/variant/array.h"
#include "core/variant/callable.h"
#include "core/variant/dictionary.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
class Object;
class Node; // helper
class Control; // helper
struct PropertyInfo;
struct MethodInfo;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
typedef Vector<uint8_t> PackedByteArray;
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 18:20:53 +00:00
typedef Vector<int32_t> PackedInt32Array;
typedef Vector<int64_t> PackedInt64Array;
typedef Vector<float> PackedFloat32Array;
typedef Vector<double> PackedFloat64Array;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
typedef Vector<String> PackedStringArray;
typedef Vector<Vector2> PackedVector2Array;
typedef Vector<Vector3> PackedVector3Array;
typedef Vector<Color> PackedColorArray;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
class Variant {
public:
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
// If this changes the table in variant_op must be updated
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
enum Type {
remove trailing whitespace
2016-03-08 23:00:52 +00:00
NIL,
// atomic types
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
BOOL,
INT,
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 18:20:53 +00:00
FLOAT,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
STRING,
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// math types
Update docs and bindings for new integer vector types
2020-02-24 16:00:40 +00:00
VECTOR2,
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
VECTOR2I,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
RECT2,
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
RECT2I,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
VECTOR3,
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
VECTOR3I,
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
TRANSFORM2D,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
PLANE,
Update docs and bindings for new integer vector types
2020-02-24 16:00:40 +00:00
QUAT,
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
AABB,
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
BASIS,
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
TRANSFORM3D,
remove trailing whitespace
2016-03-08 23:00:52 +00:00
// misc types
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
COLOR,
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
2020-02-20 21:58:05 +00:00
STRING_NAME,
Update docs and bindings for new integer vector types
2020-02-24 16:00:40 +00:00
NODE_PATH,
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
RID,
remove trailing whitespace
2016-03-08 23:00:52 +00:00
OBJECT,
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
CALLABLE,
SIGNAL,
Removal of Image from Variant, converted to a Resource.
2017-05-17 10:36:47 +00:00
DICTIONARY,
variant.h: Update comments with numeric enum values Comments got desynchronized with the actual values of the enum. To avoid anyone making some stupid mistake here, let's fix it as soon as possible.
2017-10-20 11:13:26 +00:00
ARRAY,
Update docs and bindings for new integer vector types
2020-02-24 16:00:40 +00:00
// typed arrays
PACKED_BYTE_ARRAY,
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 18:20:53 +00:00
PACKED_INT32_ARRAY,
PACKED_INT64_ARRAY,
PACKED_FLOAT32_ARRAY,
PACKED_FLOAT64_ARRAY,
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
PACKED_STRING_ARRAY,
PACKED_VECTOR2_ARRAY,
Update docs and bindings for new integer vector types
2020-02-24 16:00:40 +00:00
PACKED_VECTOR3_ARRAY,
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
PACKED_COLOR_ARRAY,
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
VARIANT_MAX
remove trailing whitespace
2016-03-08 23:00:52 +00:00
};
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
private:
Fix mismatched class/struct definition warnings [-Wmismatched-tags] Fixes the following Clang 7 warnings: ``` core/object.cpp:44:1: warning: '_ObjectDebugLock' defined as a struct here but previously declared as a class [-Wmismatched-tags] core/variant_call.cpp:43:1: warning: '_VariantCall' defined as a struct here but previously declared as a class [-Wmismatched-tags] drivers/gles3/rasterizer_storage_gles3.h:765:2: warning: 'MultiMesh' defined as a struct here but previously declared as a class [-Wmismatched-tags] editor/editor_node.h:794:1: warning: 'EditorProgress' defined as a struct here but previously declared as a class [-Wmismatched-tags] modules/bullet/rigid_body_bullet.h:230:17: warning: class 'KinematicUtilities' was previously declared as a struct [-Wmismatched-tags] modules/bullet/space_bullet.h:60:1: warning: class 'btSoftBodyWorldInfo' was previously declared as a struct [-Wmismatched-tags] scene/resources/world_2d.cpp:40:1: warning: 'SpatialIndexer2D' defined as a struct here but previously declared as a class [-Wmismatched-tags] scene/resources/world.cpp:39:1: warning: 'SpatialIndexer' defined as a struct here but previously declared as a class [-Wmismatched-tags] servers/audio/reverb_sw.cpp:60:1: warning: 'ReverbParamsSW' defined as a struct here but previously declared as a class [-Wmismatched-tags] thirdparty/bullet/BulletSoftBody/btSoftBody.h:43:1: warning: 'btSoftBodyWorldInfo' defined as a struct here but previously declared as a class [-Wmismatched-tags] ```
2018-10-01 14:46:50 +00:00
friend struct _VariantCall;
Add VariantInternal class This is used to get a direct pointer for the data inside a Variant. Added as another class instead of in Variant directly because this should only be used in special cases, so use must be explicit.
2020-09-02 18:26:28 +00:00
friend class VariantInternal;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// Variant takes 20 bytes when real_t is float, and 36 if double
// it only allocates extra memory for aabb/matrix.
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
Type type = NIL;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
struct ObjData {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
ObjectID id;
Initialize class/struct variables with default values in core/ and drivers/
2020-11-23 16:38:46 +00:00
Object *obj = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
remove trailing whitespace
2016-03-08 23:00:52 +00:00
Store arrays inside of Variant as shared. Arrays inside of Variant are unique and use reference counting. When you assign a variant containing a packed array to another, or when you call non const functions to arrays, this will work even if the array is inside a dictionary, so they will from now pass as reference. The difference with regular variant arrays is that, once passed to a function in the C++ API, they are no longer shared. This is required for security and thread safety, as those arrays are mainly used to pass data back and forth even between threads.
2020-02-23 21:01:26 +00:00
/* array helpers */
struct PackedArrayRefBase {
SafeRefCount refcount;
_FORCE_INLINE_ PackedArrayRefBase *reference() {
if (this->refcount.ref()) {
return this;
} else {
return nullptr;
}
}
static _FORCE_INLINE_ PackedArrayRefBase *reference_from(PackedArrayRefBase *p_base, PackedArrayRefBase *p_from) {
if (p_base == p_from) {
return p_base; //same thing, do nothing
}
if (p_from->reference()) {
if (p_base->refcount.unref()) {
memdelete(p_base);
}
return p_from;
} else {
return p_base; //keep, could not reference new
}
}
static _FORCE_INLINE_ void destroy(PackedArrayRefBase *p_array) {
if (p_array->refcount.unref()) {
memdelete(p_array);
}
}
_FORCE_INLINE_ virtual ~PackedArrayRefBase() {} //needs virtual destructor, but make inline
};
template <class T>
struct PackedArrayRef : public PackedArrayRefBase {
Vector<T> array;
static _FORCE_INLINE_ PackedArrayRef<T> *create() {
return memnew(PackedArrayRef<T>);
}
static _FORCE_INLINE_ PackedArrayRef<T> *create(const Vector<T> &p_from) {
return memnew(PackedArrayRef<T>(p_from));
}
static _FORCE_INLINE_ const Vector<T> &get_array(PackedArrayRefBase *p_base) {
return static_cast<PackedArrayRef<T> *>(p_base)->array;
}
static _FORCE_INLINE_ Vector<T> *get_array_ptr(const PackedArrayRefBase *p_base) {
return &const_cast<PackedArrayRef<T> *>(static_cast<const PackedArrayRef<T> *>(p_base))->array;
}
_FORCE_INLINE_ PackedArrayRef(const Vector<T> &p_from) {
array = p_from;
refcount.init();
}
_FORCE_INLINE_ PackedArrayRef() {
refcount.init();
}
};
/* end of array helpers */
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
_ALWAYS_INLINE_ ObjData &_get_obj();
_ALWAYS_INLINE_ const ObjData &_get_obj() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
union {
bool _bool;
Variant INT and REAL are now 64 bits (other types remain at 32)
2017-01-08 23:58:39 +00:00
int64_t _int;
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 18:20:53 +00:00
double _float;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
Transform2D *_transform2d;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
::AABB *_aabb;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
Basis *_basis;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
Transform3D *_transform3d;
Store arrays inside of Variant as shared. Arrays inside of Variant are unique and use reference counting. When you assign a variant containing a packed array to another, or when you call non const functions to arrays, this will work even if the array is inside a dictionary, so they will from now pass as reference. The difference with regular variant arrays is that, once passed to a function in the C++ API, they are no longer shared. This is required for security and thread safety, as those arrays are mainly used to pass data back and forth even between threads.
2020-02-23 21:01:26 +00:00
PackedArrayRefBase *packed_array;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void *_ptr; //generic pointer
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)];
Remove some C++11 polyfill defines that are no longer needed
2020-05-02 22:42:04 +00:00
} _data alignas(8);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void reference(const Variant &p_variant);
Refactored variant constructor logic
2020-11-09 03:19:09 +00:00
void _clear_internal();
_FORCE_INLINE_ void clear() {
static const bool needs_deinit[Variant::VARIANT_MAX] = {
false, //NIL,
false, //BOOL,
false, //INT,
false, //FLOAT,
true, //STRING,
false, //VECTOR2,
false, //VECTOR2I,
false, //RECT2,
false, //RECT2I,
false, //VECTOR3,
false, //VECTOR3I,
true, //TRANSFORM2D,
false, //PLANE,
false, //QUAT,
true, //AABB,
true, //BASIS,
true, //TRANSFORM,
// misc types
false, //COLOR,
true, //STRING_NAME,
true, //NODE_PATH,
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
false, //RID,
Refactored variant constructor logic
2020-11-09 03:19:09 +00:00
true, //OBJECT,
true, //CALLABLE,
true, //SIGNAL,
true, //DICTIONARY,
true, //ARRAY,
// typed arrays
true, //PACKED_BYTE_ARRAY,
true, //PACKED_INT32_ARRAY,
true, //PACKED_INT64_ARRAY,
true, //PACKED_FLOAT32_ARRAY,
true, //PACKED_FLOAT64_ARRAY,
true, //PACKED_STRING_ARRAY,
true, //PACKED_VECTOR2_ARRAY,
true, //PACKED_VECTOR3_ARRAY,
true, //PACKED_COLOR_ARRAY,
};
if (unlikely(needs_deinit[type])) { //make it fast for types that dont need deinit
_clear_internal();
}
type = NIL;
}
static void _register_variant_operators();
static void _unregister_variant_operators();
static void _register_variant_methods();
static void _unregister_variant_methods();
static void _register_variant_setters_getters();
static void _unregister_variant_setters_getters();
static void _register_variant_constructors();
static void _unregister_variant_constructors();
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static void _register_variant_utility_functions();
static void _unregister_variant_utility_functions();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
public:
Store arrays inside of Variant as shared. Arrays inside of Variant are unique and use reference counting. When you assign a variant containing a packed array to another, or when you call non const functions to arrays, this will work even if the array is inside a dictionary, so they will from now pass as reference. The difference with regular variant arrays is that, once passed to a function in the C++ API, they are no longer shared. This is required for security and thread safety, as those arrays are mainly used to pass data back and forth even between threads.
2020-02-23 21:01:26 +00:00
_FORCE_INLINE_ Type get_type() const {
return type;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
static String get_type_name(Variant::Type p_type);
-More strict argument type-checking, will make many bugs visible, fixes #1809 -added NOTIFICATION_INSTANCED
2015-05-04 21:30:57 +00:00
static bool can_convert(Type p_type_from, Type p_type_to);
static bool can_convert_strict(Type p_type_from, Type p_type_to);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
bool is_ref() const;
Store arrays inside of Variant as shared. Arrays inside of Variant are unique and use reference counting. When you assign a variant containing a packed array to another, or when you call non const functions to arrays, this will work even if the array is inside a dictionary, so they will from now pass as reference. The difference with regular variant arrays is that, once passed to a function in the C++ API, they are no longer shared. This is required for security and thread safety, as those arrays are mainly used to pass data back and forth even between threads.
2020-02-23 21:01:26 +00:00
_FORCE_INLINE_ bool is_num() const {
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 18:20:53 +00:00
return type == INT || type == FLOAT;
Style: Remove unnecessary semicolons from `core` Semicolons are not necessary after function definitions or control flow blocks, and having some code use them makes things inconsistent (and occasionally can mess up `clang-format`'s formatting). Removing them is tedious work though, I had to do this manually (regex + manual review) as I couldn't find a tool for that. All other code folders would need to get the same treatment.
2020-05-19 13:46:49 +00:00
}
Store arrays inside of Variant as shared. Arrays inside of Variant are unique and use reference counting. When you assign a variant containing a packed array to another, or when you call non const functions to arrays, this will work even if the array is inside a dictionary, so they will from now pass as reference. The difference with regular variant arrays is that, once passed to a function in the C++ API, they are no longer shared. This is required for security and thread safety, as those arrays are mainly used to pass data back and forth even between threads.
2020-02-23 21:01:26 +00:00
_FORCE_INLINE_ bool is_array() const {
return type >= ARRAY;
Style: Remove unnecessary semicolons from `core` Semicolons are not necessary after function definitions or control flow blocks, and having some code use them makes things inconsistent (and occasionally can mess up `clang-format`'s formatting). Removing them is tedious work though, I had to do this manually (regex + manual review) as I couldn't find a tool for that. All other code folders would need to get the same treatment.
2020-05-19 13:46:49 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
bool is_shared() const;
bool is_zero() const;
Several performance improvements, mainly in loading and instancing scenes and resources. A general speedup should be apparent, with even more peformance increase when compiling optimized. WARNING: Tested and it seems to work, but if something breaks, please report.
2015-06-29 03:29:49 +00:00
bool is_one() const;
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
bool is_null() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator bool() const;
operator signed int() const;
operator unsigned int() const; // this is the real one
operator signed short() const;
operator unsigned short() const;
operator signed char() const;
operator unsigned char() const;
//operator long unsigned int() const;
operator int64_t() const;
operator uint64_t() const;
#ifdef NEED_LONG_INT
operator signed long() const;
operator unsigned long() const;
#endif
ObjectID converted to a structure, fixes many bugs where used incorrectly as 32 bits.
2020-02-12 17:24:06 +00:00
operator ObjectID() const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 10:43:20 +00:00
operator char32_t() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator float() const;
operator double() const;
operator String() const;
operator StringName() const;
operator Vector2() const;
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
operator Vector2i() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Rect2() const;
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
operator Rect2i() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Vector3() const;
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
operator Vector3i() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Plane() const;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
operator ::AABB() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Quat() const;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 03:52:51 +00:00
operator Basis() const;
operator Transform2D() const;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 07:36:08 +00:00
operator Transform3D() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Color() const;
operator NodePath() const;
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
operator ::RID() const;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 15:38:03 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
operator Object *() const;
operator Node *() const;
operator Control *() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
operator Callable() const;
operator Signal() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Dictionary() const;
operator Array() const;
remove trailing whitespace
2016-03-08 23:00:52 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Vector<uint8_t>() const;
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 18:20:53 +00:00
operator Vector<int32_t>() const;
operator Vector<int64_t>() const;
operator Vector<float>() const;
operator Vector<double>() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Vector<String>() const;
operator Vector<Vector3>() const;
operator Vector<Color>() const;
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
operator Vector<Plane>() const;
operator Vector<Face3>() const;
operator Vector<Variant>() const;
operator Vector<StringName>() const;
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
operator Vector<::RID>() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Vector<Vector2>() const;
// some core type enums to convert to
Rename Control margin to offset
2020-12-22 16:24:29 +00:00
operator Side() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
operator Orientation() const;
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 00:48:18 +00:00
operator IPAddress() const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 19:03:10 +00:00
Object *get_validated_object() const;
Object *get_validated_object_with_check(bool &r_previously_freed) const;
few bugs fixed thanks to explicit bool constructor and clang. explicit bool constructor has thus now been removed, as it served it's mission!
2017-08-06 00:43:10 +00:00
Variant(bool p_bool);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Variant(signed int p_int); // real one
Variant(unsigned int p_int);
#ifdef NEED_LONG_INT
Variant(signed long p_long); // real one
Variant(unsigned long p_long);
#endif
Variant(signed short p_short); // real one
Variant(unsigned short p_short);
Variant(signed char p_char); // real one
Variant(unsigned char p_char);
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
Variant(int64_t p_int); // real one
Variant(uint64_t p_int);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Variant(float p_float);
Variant(double p_double);
ObjectID converted to a structure, fixes many bugs where used incorrectly as 32 bits.
2020-02-12 17:24:06 +00:00
Variant(const ObjectID &p_id);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const String &p_string);
Variant(const StringName &p_string);
Variant(const char *const p_cstring);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 10:43:20 +00:00
Variant(const char32_t *p_wstring);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Vector2 &p_vector2);
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
Variant(const Vector2i &p_vector2i);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Rect2 &p_rect2);
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
Variant(const Rect2i &p_rect2i);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Vector3 &p_vector3);
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 03:26:41 +00:00
Variant(const Vector3i &p_vector3i);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Plane &p_plane);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 02:09:00 +00:00
Variant(const ::AABB &p_aabb);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Quat &p_quat);
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
Variant(const Basis &p_matrix);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Transform2D &p_transform);
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Variant(const Transform3D &p_transform);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Color &p_color);
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
Variant(const NodePath &p_node_path);
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
Variant(const ::RID &p_rid);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Object *p_object);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
Variant(const Callable &p_callable);
Variant(const Signal &p_signal);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Dictionary &p_dictionary);
Variant(const Array &p_array);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
Variant(const Vector<Plane> &p_array); // helper
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 18:20:53 +00:00
Variant(const Vector<uint8_t> &p_byte_array);
Variant(const Vector<int32_t> &p_int32_array);
Variant(const Vector<int64_t> &p_int64_array);
Variant(const Vector<float> &p_float32_array);
Variant(const Vector<double> &p_float64_array);
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 21:06:54 +00:00
Variant(const Vector<String> &p_string_array);
Variant(const Vector<Vector3> &p_vector3_array);
Variant(const Vector<Color> &p_color_array);
Variant(const Vector<Face3> &p_face_array);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Vector<Variant> &p_array);
Some code changed with Clang-Tidy
2019-06-26 13:08:25 +00:00
Variant(const Vector<StringName> &p_array);
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 13:53:05 +00:00
Variant(const Vector<::RID> &p_array); // helper
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Vector<Vector2> &p_array); // helper
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 00:48:18 +00:00
Variant(const IPAddress &p_address);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
// If this changes the table in variant_op must be updated
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
enum Operator {
Fix typos with codespell Found via `codespell -q 3 --skip="./thirdparty,./editor/translations" -I ../godot-word-whitelist.txt` Whitelist consists of: ``` ang doubleclick lod nd que te unselect ```
2018-02-21 16:30:55 +00:00
//comparison
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
OP_EQUAL,
OP_NOT_EQUAL,
OP_LESS,
OP_LESS_EQUAL,
OP_GREATER,
OP_GREATER_EQUAL,
//mathematic
OP_ADD,
Move Variant::evaluate() switch to computed goto In an effort to make GDScript a little faster replace the double switch() with a computed goto on compilers that set __GNUC__. For compilers that don't support computed goto it will fall back to regular switch/case statements. In addition disable using boolean values in a mathematical context. Now boolean values can only be compared with other booleans. Booleans will also no longer be coerced to integers. This PR replaces #11308 and fixes #11291
2017-09-17 00:32:05 +00:00
OP_SUBTRACT,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
OP_MULTIPLY,
OP_DIVIDE,
OP_NEGATE,
Added small modification on parser for '+'
2016-10-12 21:43:59 +00:00
OP_POSITIVE,
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
OP_MODULE,
//bitwise
OP_SHIFT_LEFT,
OP_SHIFT_RIGHT,
OP_BIT_AND,
OP_BIT_OR,
OP_BIT_XOR,
OP_BIT_NEGATE,
//logic
OP_AND,
OP_OR,
OP_XOR,
OP_NOT,
//containment
OP_IN,
OP_MAX
};
static String get_operator_name(Operator p_op);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid);
static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) {
bool valid = true;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Variant res;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
evaluate(p_op, p_a, p_b, res, valid);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return res;
}
Make sure operators appear in the docs too Add "operator" and "constructor" qualifiers to make it easier to see in the docs.
2020-11-09 17:11:15 +00:00
static Variant::Type get_operator_return_type(Operator p_operator, Type p_type_a, Type p_type_b);
Refactored Variant Operators. -Using classes to call and a table -For typed code (GDS or GDNative), can obtain functions to call prevalidated or ptr.
2020-11-05 02:01:55 +00:00
typedef void (*ValidatedOperatorEvaluator)(const Variant *left, const Variant *right, Variant *r_ret);
static ValidatedOperatorEvaluator get_validated_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b);
typedef void (*PTROperatorEvaluator)(const void *left, const void *right, void *r_ret);
static PTROperatorEvaluator get_ptr_operator_evaluator(Operator p_operator, Type p_type_a, Type p_type_b);
AnimationTreePlayer: blend value tracks (closes #2299) Variant: - zero() sets a Variant to the appropriate type of zero value - blend() blends part of one Variant on top of another.
2016-02-18 03:34:49 +00:00
void zero();
Duplicate Arrays and Dictionaries when instancing scene in editor Also, add deep (=false) parameter to Array.duplicate and Dictionary.duplicate Fixes #13971
2018-03-09 19:16:08 +00:00
Variant duplicate(bool deep = false) const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static void blend(const Variant &a, const Variant &b, float c, Variant &r_dst);
static void interpolate(const Variant &a, const Variant &b, float c, Variant &r_dst);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
/* Built-In Methods */
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 18:59:37 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
typedef void (*ValidatedBuiltInMethod)(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret);
typedef void (*PTRBuiltInMethod)(void *p_base, const void **p_args, void *r_ret, int p_argcount);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 18:59:37 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static bool has_builtin_method(Variant::Type p_type, const StringName &p_method);
static ValidatedBuiltInMethod get_validated_builtin_method(Variant::Type p_type, const StringName &p_method);
static PTRBuiltInMethod get_ptr_builtin_method(Variant::Type p_type, const StringName &p_method);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 18:59:37 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static int get_builtin_method_argument_count(Variant::Type p_type, const StringName &p_method);
static Variant::Type get_builtin_method_argument_type(Variant::Type p_type, const StringName &p_method, int p_argument);
static String get_builtin_method_argument_name(Variant::Type p_type, const StringName &p_method, int p_argument);
static Vector<Variant> get_builtin_method_default_arguments(Variant::Type p_type, const StringName &p_method);
static bool has_builtin_method_return_value(Variant::Type p_type, const StringName &p_method);
static Variant::Type get_builtin_method_return_type(Variant::Type p_type, const StringName &p_method);
static bool is_builtin_method_const(Variant::Type p_type, const StringName &p_method);
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 13:56:34 +00:00
static bool is_builtin_method_static(Variant::Type p_type, const StringName &p_method);
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static bool is_builtin_method_vararg(Variant::Type p_type, const StringName &p_method);
static void get_builtin_method_list(Variant::Type p_type, List<StringName> *p_list);
Add helper count function to Variant To get counts of items before getting the list, which is useful for GDNative so users can pre-allocate the buffer with the correct size without having to get the list twice.
2020-12-27 14:09:06 +00:00
static int get_builtin_method_count(Variant::Type p_type);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 18:59:37 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
void call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant call(const StringName &p_method, const Variant &p_arg1 = Variant(), const Variant &p_arg2 = Variant(), const Variant &p_arg3 = Variant(), const Variant &p_arg4 = Variant(), const Variant &p_arg5 = Variant());
-make signals throw an error when target method is not found, fixes #2036 -removed 4 arguments limit for emit_signal() from script -remvoed 4 arguments limit for call_deferred() from script
2016-01-04 12:35:21 +00:00
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 13:56:34 +00:00
static void call_static(Variant::Type p_type, const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
static String get_call_error_text(const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Callable::CallError &ce);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 19:27:19 +00:00
static String get_call_error_text(Object *p_base, const StringName &p_method, const Variant **p_argptrs, int p_argcount, const Callable::CallError &ce);
static String get_callable_error_text(const Callable &p_callable, const Variant **p_argptrs, int p_argcount, const Callable::CallError &ce);
-make signals throw an error when target method is not found, fixes #2036 -removed 4 arguments limit for emit_signal() from script -remvoed 4 arguments limit for call_deferred() from script
2016-01-04 12:35:21 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
//dynamic (includes Object)
void get_method_list(List<MethodInfo> *p_list) const;
bool has_method(const StringName &p_method) const;
/* Constructors */
Use pointer parameters in Variant function pointers Instead of references. This is needed because those function pointers are used in GDNative which needs to work with plain C, which doesn't support passing parameters by reference.
2020-12-10 20:12:02 +00:00
typedef void (*ValidatedConstructor)(Variant *r_base, const Variant **p_args);
Refactored variant constructor logic
2020-11-09 03:19:09 +00:00
typedef void (*PTRConstructor)(void *base, const void **p_args);
static int get_constructor_count(Variant::Type p_type);
static ValidatedConstructor get_validated_constructor(Variant::Type p_type, int p_constructor);
static PTRConstructor get_ptr_constructor(Variant::Type p_type, int p_constructor);
static int get_constructor_argument_count(Variant::Type p_type, int p_constructor);
static Variant::Type get_constructor_argument_type(Variant::Type p_type, int p_constructor, int p_argument);
static String get_constructor_argument_name(Variant::Type p_type, int p_constructor, int p_argument);
static void construct(Variant::Type, Variant &base, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
static void get_constructor_list(Type p_type, List<MethodInfo> *r_list); //convenience
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
/* Properties */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
void set_named(const StringName &p_member, const Variant &p_value, bool &r_valid);
Variant get_named(const StringName &p_member, bool &r_valid) const;
typedef void (*ValidatedSetter)(Variant *base, const Variant *value);
typedef void (*ValidatedGetter)(const Variant *base, Variant *value);
static bool has_member(Variant::Type p_type, const StringName &p_member);
static Variant::Type get_member_type(Variant::Type p_type, const StringName &p_member);
static void get_member_list(Type p_type, List<StringName> *r_members);
Add helper count function to Variant To get counts of items before getting the list, which is useful for GDNative so users can pre-allocate the buffer with the correct size without having to get the list twice.
2020-12-27 14:09:06 +00:00
static int get_member_count(Type p_type);
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
static ValidatedSetter get_member_validated_setter(Variant::Type p_type, const StringName &p_member);
static ValidatedGetter get_member_validated_getter(Variant::Type p_type, const StringName &p_member);
typedef void (*PTRSetter)(void *base, const void *value);
typedef void (*PTRGetter)(const void *base, void *value);
static PTRSetter get_member_ptr_setter(Variant::Type p_type, const StringName &p_member);
static PTRGetter get_member_ptr_getter(Variant::Type p_type, const StringName &p_member);
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
/* Indexing */
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
static bool has_indexing(Variant::Type p_type);
static Variant::Type get_indexed_element_type(Variant::Type p_type);
Use pointer parameters in Variant function pointers Instead of references. This is needed because those function pointers are used in GDNative which needs to work with plain C, which doesn't support passing parameters by reference.
2020-12-10 20:12:02 +00:00
typedef void (*ValidatedIndexedSetter)(Variant *base, int64_t index, const Variant *value, bool *oob);
typedef void (*ValidatedIndexedGetter)(const Variant *base, int64_t index, Variant *value, bool *oob);
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
static ValidatedIndexedSetter get_member_validated_indexed_setter(Variant::Type p_type);
static ValidatedIndexedGetter get_member_validated_indexed_getter(Variant::Type p_type);
typedef void (*PTRIndexedSetter)(void *base, int64_t index, const void *value);
typedef void (*PTRIndexedGetter)(const void *base, int64_t index, void *value);
static PTRIndexedSetter get_member_ptr_indexed_setter(Variant::Type p_type);
static PTRIndexedGetter get_member_ptr_indexed_getter(Variant::Type p_type);
void set_indexed(int64_t p_index, const Variant &p_value, bool &r_valid, bool &r_oob);
Variant get_indexed(int64_t p_index, bool &r_valid, bool &r_oob) const;
uint64_t get_indexed_size() const;
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
/* Keying */
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
static bool is_keyed(Variant::Type p_type);
Use pointer parameters in Variant function pointers Instead of references. This is needed because those function pointers are used in GDNative which needs to work with plain C, which doesn't support passing parameters by reference.
2020-12-10 20:12:02 +00:00
typedef void (*ValidatedKeyedSetter)(Variant *base, const Variant *key, const Variant *value, bool *valid);
typedef void (*ValidatedKeyedGetter)(const Variant *base, const Variant *key, Variant *value, bool *valid);
typedef bool (*ValidatedKeyedChecker)(const Variant *base, const Variant *key, bool *valid);
Refactored variant setters/getters -Discern between named, indexed and keyed -Get direct access to functions for typed GDScript and GDNative bindings -Small changes to some classes in order to work with the new setget binder
2020-11-07 01:29:22 +00:00
static ValidatedKeyedSetter get_member_validated_keyed_setter(Variant::Type p_type);
static ValidatedKeyedGetter get_member_validated_keyed_getter(Variant::Type p_type);
static ValidatedKeyedChecker get_member_validated_keyed_checker(Variant::Type p_type);
typedef void (*PTRKeyedSetter)(void *base, const void *key, const void *value);
typedef void (*PTRKeyedGetter)(const void *base, const void *key, void *value);
typedef bool (*PTRKeyedChecker)(const void *base, const void *key);
static PTRKeyedSetter get_member_ptr_keyed_setter(Variant::Type p_type);
static PTRKeyedGetter get_member_ptr_keyed_getter(Variant::Type p_type);
static PTRKeyedChecker get_member_ptr_keyed_checker(Variant::Type p_type);
void set_keyed(const Variant &p_key, const Variant &p_value, bool &r_valid);
Variant get_keyed(const Variant &p_key, bool &r_valid) const;
bool has_key(const Variant &p_key, bool &r_valid) const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
/* Generic */
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
void set(const Variant &p_index, const Variant &p_value, bool *r_valid = nullptr);
Variant get(const Variant &p_index, bool *r_valid = nullptr) const;
bool in(const Variant &p_index, bool *r_valid = nullptr) const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool iter_init(Variant &r_iter, bool &r_valid) const;
bool iter_next(Variant &r_iter, bool &r_valid) const;
Variant iter_get(const Variant &r_iter, bool &r_valid) const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void get_property_list(List<PropertyInfo> *p_list) const;
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static void call_utility_function(const StringName &p_name, Variant *r_ret, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
static bool has_utility_function(const StringName &p_name);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
typedef void (*ValidatedUtilityFunction)(Variant *r_ret, const Variant **p_args, int p_argcount);
typedef void (*PTRUtilityFunction)(void *r_ret, const void **p_args, int p_argcount);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static ValidatedUtilityFunction get_validated_utility_function(const StringName &p_name);
static PTRUtilityFunction get_ptr_utility_function(const StringName &p_name);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
enum UtilityFunctionType {
UTILITY_FUNC_TYPE_MATH,
UTILITY_FUNC_TYPE_RANDOM,
UTILITY_FUNC_TYPE_GENERAL,
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
};
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static UtilityFunctionType get_utility_function_type(const StringName &p_name);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static int get_utility_function_argument_count(const StringName &p_name);
static Variant::Type get_utility_function_argument_type(const StringName &p_name, int p_arg);
static String get_utility_function_argument_name(const StringName &p_name, int p_arg);
static bool has_utility_function_return_value(const StringName &p_name);
static Variant::Type get_utility_function_return_type(const StringName &p_name);
static bool is_utility_function_vararg(const StringName &p_name);
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
Refactor variant built-in methods yet again. * Using C-style function pointers now, InternalMethod is gone. * This ensures much better performance in typed code. * Renamed builtin_funcs to utility_funcs, to avoid naming confusion
2020-11-11 16:16:08 +00:00
static void get_utility_function_list(List<StringName> *r_functions);
Add helper count function to Variant To get counts of items before getting the list, which is useful for GDNative so users can pre-allocate the buffer with the correct size without having to get the list twice.
2020-12-27 14:09:06 +00:00
static int get_utility_function_count();
Create Variant built-in functions. -Moved Expression to use this, removed its own. -Eventually GDScript/VisualScript/GDNative need to be moved to this. -Given the JSON functions were hacked-in, removed them and created a new JSONParser class -Made sure these functions appear properly in documentation, since they will be removed from GDScript
2020-11-10 21:31:33 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//argsVariant call()
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool operator==(const Variant &p_variant) const;
bool operator!=(const Variant &p_variant) const;
bool operator<(const Variant &p_variant) const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
uint32_t hash() const;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
bool hash_compare(const Variant &p_variant) const;
Allow booleanization of all types We now allow booleanization of all types. This means that empty versions of all types now evaluate to false. So a Vector2(0,0), Dictionary(), etc. This allows you to write GDScript like: if not Dictionary(): print("Empty dict") Booleanization can now also no longer fail. There is no more valid flag, this changes Variant and GDNative API.
2017-09-18 18:02:47 +00:00
bool booleanize() const;
Don't crash on printing nested types When adding an Array or Dictionary to itself operator String() got in an infinite loop. This commit adds a stack to operator String() (Through the use of a new 'stringify method'). This stack keeps track of all unique Arrays and Dictionaries it has seen. When a duplicate is found only a static string is printed '[...]' or '{...}'. This mirror Python's behavior in a similar case.
2019-04-19 23:57:29 +00:00
String stringify(List<const void *> &stack) const;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void static_assign(const Variant &p_variant);
Allow some non-integer built-in constants in gdscript
2017-12-15 15:43:27 +00:00
static void get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants);
Add helper count function to Variant To get counts of items before getting the list, which is useful for GDNative so users can pre-allocate the buffer with the correct size without having to get the list twice.
2020-12-27 14:09:06 +00:00
static int get_constants_count_for_type(Variant::Type p_type);
Allow some non-integer built-in constants in gdscript
2017-12-15 15:43:27 +00:00
static bool has_constant(Variant::Type p_type, const StringName &p_value);
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
static Variant get_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid = nullptr);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud);
typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value);
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 04:19:46 +00:00
-Changed var2str and str2var in GDScript to use VariantWriter and VariantParser -It is now finally possible to parse back a variant from text!
2015-12-31 03:54:00 +00:00
String get_construct_string() const;
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
static void construct_from_string(const String &p_string, Variant &r_value, ObjectConstruct p_obj_construct = nullptr, void *p_construct_ud = nullptr);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
void operator=(const Variant &p_variant); // only this is enough for all the other types
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
Refactored variant constructor logic
2020-11-09 03:19:09 +00:00
static void register_types();
static void unregister_types();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant(const Variant &p_variant);
Port member initialization from constructor to declaration (C++11) Using `clang-tidy`'s `modernize-use-default-member-init` check and manual review of the changes, and some extra manual changes that `clang-tidy` failed to do. Also went manually through all of `core` to find occurrences that `clang-tidy` couldn't handle, especially all initializations done in a constructor without using initializer lists.
2020-05-12 15:01:17 +00:00
_FORCE_INLINE_ Variant() {}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
_FORCE_INLINE_ ~Variant() {
Refactored variant constructor logic
2020-11-09 03:19:09 +00:00
clear();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
//typedef Dictionary Dictionary; no
//typedef Array Array;
Vector<Variant> varray();
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Vector<Variant> varray(const Variant &p_arg1);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4);
Vector<Variant> varray(const Variant &p_arg1, const Variant &p_arg2, const Variant &p_arg3, const Variant &p_arg4, const Variant &p_arg5);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
struct VariantHasher {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); }
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
};
Correct hash behavior for floating point numbers This fixes HashMap where a key or part of a key is a floating point number. To fix this the following has been done: * HashMap now takes an extra template argument Comparator. This class gets used to compare keys. The default Comperator now works correctly for common types and floating point numbets. * Variant implements ::hash_compare() now. This function implements nan-safe comparison for all types with components that contain floating point numbers. * Variant now has a VariantComparator which uses Variant::hash_compare() safely compare floating point components of variant's types. * The hash functions for floating point numbers will now normalize NaN values so that all floating point numbers that are NaN hash to the same value. C++ module writers that want to use HashMap internally in their modules can now also safeguard against this crash by defining their on Comperator class that safely compares their types. GDScript users, or writers of modules that don't use HashMap internally in their modules don't need to do anything. This fixes #7354 and fixes #6947.
2017-02-15 13:41:16 +00:00
struct VariantComparator {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); }
Correct hash behavior for floating point numbers This fixes HashMap where a key or part of a key is a floating point number. To fix this the following has been done: * HashMap now takes an extra template argument Comparator. This class gets used to compare keys. The default Comperator now works correctly for common types and floating point numbets. * Variant implements ::hash_compare() now. This function implements nan-safe comparison for all types with components that contain floating point numbers. * Variant now has a VariantComparator which uses Variant::hash_compare() safely compare floating point components of variant's types. * The hash functions for floating point numbers will now normalize NaN values so that all floating point numbers that are NaN hash to the same value. C++ module writers that want to use HashMap internally in their modules can now also safeguard against this crash by defining their on Comperator class that safely compares their types. GDScript users, or writers of modules that don't use HashMap internally in their modules don't need to do anything. This fixes #7354 and fixes #6947.
2017-02-15 13:41:16 +00:00
};
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Variant::ObjData &Variant::_get_obj() {
return *reinterpret_cast<ObjData *>(&_data._mem[0]);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
const Variant::ObjData &Variant::_get_obj() const {
return *reinterpret_cast<const ObjData *>(&_data._mem[0]);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
String vformat(const String &p_text, const Variant &p1 = Variant(), const Variant &p2 = Variant(), const Variant &p3 = Variant(), const Variant &p4 = Variant(), const Variant &p5 = Variant());
Style: Harmonize header guards to style guide [Core]
2020-03-25 10:10:34 +00:00
#endif // VARIANT_H