asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/core/variant/variant.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

864 lines
30 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/**************************************************************************/
/* variant.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifndef VARIANT_H
#define VARIANT_H
Use "enum class" for input enums
2021-08-13 23:31:57 +02:00
#include "core/input/input_enums.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 18:13:45 +02: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 06:24:02 +01: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 23:33:38 +01: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 18:13:45 +02:00
#include "core/math/face3.h"
#include "core/math/plane.h"
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
#include "core/math/projection.h"
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
#include "core/math/quaternion.h"
Core: Move Rect2i to its own `rect2i.h` header And take the opportunity to improve interdependencies a bit with forward declares where possible.
2022-02-04 13:28:02 +01:00
#include "core/math/rect2.h"
#include "core/math/rect2i.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 18:13:45 +02:00
#include "core/math/transform_2d.h"
Rename files and the exposed name for Transform3D
2021-02-27 05:26:56 +01:00
#include "core/math/transform_3d.h"
Core: Move Rect2i to its own `rect2i.h` header And take the opportunity to improve interdependencies a bit with forward declares where possible.
2022-02-04 13:28:02 +01:00
#include "core/math/vector2.h"
Core: Move Vector2i to its own `vector2i.h` header Also reduce interdependencies and clean up a bit.
2022-02-04 15:35:14 +01:00
#include "core/math/vector2i.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 18:13:45 +02: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 04:26:41 +01:00
#include "core/math/vector3i.h"
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
#include "core/math/vector4.h"
#include "core/math/vector4i.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 23:33:38 +01:00
#include "core/object/object_id.h"
Use "enum class" for input enums
2021-08-13 23:31:57 +02:00
#include "core/os/keyboard.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 23:33:38 +01:00
#include "core/string/node_path.h"
#include "core/string/ustring.h"
Variant memory pools Memory pools via PagedAllocator for Transform2D, Transform3D, Basis and AABB.
2022-05-20 14:28:44 +02:00
#include "core/templates/paged_allocator.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 23:33:38 +01:00
#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 02:10:30 +01:00
class Object;
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 22:06:54 +01: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 19:20:53 +01: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 22:06:54 +01:00
typedef Vector<String> PackedStringArray;
typedef Vector<Vector2> PackedVector2Array;
typedef Vector<Vector3> PackedVector3Array;
typedef Vector<Color> PackedColorArray;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 02:32:05 +02:00
// If this changes the table in variant_op must be updated
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
enum Type {
remove trailing whitespace
2016-03-09 00:00:52 +01:00
NIL,
// atomic types
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 19:20:53 +01:00
FLOAT,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
STRING,
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
// math types
Update docs and bindings for new integer vector types
2020-02-24 17:00:40 +01: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 04:26:41 +01:00
VECTOR2I,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
RECT2I,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01: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 04:52:51 +01:00
TRANSFORM2D,
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
VECTOR4,
VECTOR4I,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
PLANE,
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
QUATERNION,
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 03:09:00 +01: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 04:52:51 +01:00
BASIS,
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 09:36:08 +02:00
TRANSFORM3D,
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
PROJECTION,
remove trailing whitespace
2016-03-09 00:00:52 +01:00
// misc types
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
COLOR,
Added StringName as a variant type. Also changed all relevant properties defined manually to StringName.
2020-02-20 22:58:05 +01:00
STRING_NAME,
Update docs and bindings for new integer vector types
2020-02-24 17:00:40 +01: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 14:53:05 +01:00
RID,
remove trailing whitespace
2016-03-09 00:00:52 +01:00
OBJECT,
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
CALLABLE,
SIGNAL,
Removal of Image from Variant, converted to a Resource.
2017-05-17 12:36:47 +02: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 13:13:26 +02:00
ARRAY,
Update docs and bindings for new integer vector types
2020-02-24 17:00:40 +01: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 19:20:53 +01: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 22:06:54 +01:00
PACKED_STRING_ARRAY,
PACKED_VECTOR2_ARRAY,
Update docs and bindings for new integer vector types
2020-02-24 17:00:40 +01: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 22:06:54 +01:00
PACKED_COLOR_ARRAY,
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
VARIANT_MAX
remove trailing whitespace
2016-03-09 00:00:52 +01:00
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
[Net] Fix Marshalls infinite recursion crash. Variants like dictionaries and arrays can have cyclic references, which caused `encode_variant` to run an infinite recursion. Instead of keeping a stack and looking for cyclic references which would make serialization slower, this commit adds a `MAX_RECURSION_DEPTH` constant to Variant, and have `encode_variant` keep track of the current recursion depth, bailing when it's too high since this likely means a cyclic reference has been encountered.
2021-07-30 15:43:01 +02:00
enum {
// Maximum recursion depth allowed when serializing variants.
MAX_RECURSION_DEPTH = 1024,
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
private:
Variant memory pools Memory pools via PagedAllocator for Transform2D, Transform3D, Basis and AABB.
2022-05-20 14:28:44 +02:00
struct Pools {
union BucketSmall {
BucketSmall() {}
~BucketSmall() {}
Transform2D _transform2d;
::AABB _aabb;
};
Variant large bucket memory pool - for Projection Add a larger bucket size pool for the new Projection Matrix.
2022-08-02 17:27:57 +02:00
union BucketMedium {
BucketMedium() {}
~BucketMedium() {}
Basis _basis;
Transform3D _transform3d;
};
Variant memory pools Memory pools via PagedAllocator for Transform2D, Transform3D, Basis and AABB.
2022-05-20 14:28:44 +02:00
union BucketLarge {
BucketLarge() {}
~BucketLarge() {}
Variant large bucket memory pool - for Projection Add a larger bucket size pool for the new Projection Matrix.
2022-08-02 17:27:57 +02:00
Projection _projection;
Variant memory pools Memory pools via PagedAllocator for Transform2D, Transform3D, Basis and AABB.
2022-05-20 14:28:44 +02:00
};
static PagedAllocator<BucketSmall, true> _bucket_small;
Variant large bucket memory pool - for Projection Add a larger bucket size pool for the new Projection Matrix.
2022-08-02 17:27:57 +02:00
static PagedAllocator<BucketMedium, true> _bucket_medium;
Variant memory pools Memory pools via PagedAllocator for Transform2D, Transform3D, Basis and AABB.
2022-05-20 14:28:44 +02:00
static PagedAllocator<BucketLarge, true> _bucket_large;
};
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 16:46:50 +02: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 20:26:28 +02:00
friend class VariantInternal;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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-09 00:00:52 +01: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 17:01:17 +02:00
Type type = NIL;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct ObjData {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 20:03:10 +01:00
ObjectID id;
Initialize class/struct variables with default values in core/ and drivers/
2020-11-23 17:38:46 +01:00
Object *obj = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
remove trailing whitespace
2016-03-09 00:00:52 +01: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 22:01:26 +01: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 20:03:10 +01:00
_ALWAYS_INLINE_ ObjData &_get_obj();
_ALWAYS_INLINE_ const ObjData &_get_obj() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
union {
bool _bool;
Variant INT and REAL are now 64 bits (other types remain at 32)
2017-01-09 00:58:39 +01: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 19:20:53 +01: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 04:52:51 +01:00
Transform2D *_transform2d;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 03:09:00 +01: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 04:52:51 +01:00
Basis *_basis;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 09:36:08 +02:00
Transform3D *_transform3d;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
Projection *_projection;
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 22:01:26 +01:00
PackedArrayRefBase *packed_array;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void *_ptr; //generic pointer
Improve extension system - Fix library loading and initialization. - Add extra methods/parameters in the interface needed by extenstions. - Add Variant destructors and functions for extracting values and creating Variants from values.
2021-07-29 15:53:05 +02:00
uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]{ 0 };
Remove some C++11 polyfill defines that are no longer needed
2020-05-03 00:42:04 +02:00
} _data alignas(8);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void reference(const Variant &p_variant);
Fix Variant Ref<> assignment. -Creating from object pointer via funcptr API was missing reference initialization. -Supersedes https://github.com/godotengine/godot-cpp/pull/662 -Fixes several crashes in GDExtension
2022-02-11 12:30:49 +01:00
static bool initialize_ref(Object *p_object);
Refactored variant constructor logic
2020-11-09 04:19:09 +01: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,
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
false, //VECTOR4,
false, //VECTOR4I,
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
false, //PLANE,
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
false, //QUATERNION,
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
true, //AABB,
true, //BASIS,
true, //TRANSFORM,
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
true, //PROJECTION,
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
// 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 14:53:05 +01:00
false, //RID,
Refactored variant constructor logic
2020-11-09 04:19:09 +01: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,
};
Fix various typos with codespell Found via `codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,fave,findn,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint`
2021-07-07 17:17:32 +02:00
if (unlikely(needs_deinit[type])) { // Make it fast for types that don't need deinit.
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
_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();
Improve extension system - Fix library loading and initialization. - Add extra methods/parameters in the interface needed by extenstions. - Add Variant destructors and functions for extracting values and creating Variants from values.
2021-07-29 15:53:05 +02:00
static void _unregister_variant_destructors();
static void _register_variant_destructors();
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
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 17:16:08 +01:00
static void _register_variant_utility_functions();
static void _unregister_variant_utility_functions();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
void _variant_call_error(const String &p_method, Callable::CallError &error);
// Avoid accidental conversion. If you reached this point, it's because you most likely forgot to dereference
// a Variant pointer (so add * like this: *variant_pointer).
Variant(const Variant *) {}
Variant(const 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 16:44:50 +01: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 22:01:26 +01:00
_FORCE_INLINE_ Type get_type() const {
return type;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 23:30:57 +02: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);
GDScript: Fix setter being called in chains for shared types When a type is shared (i.e. passed by reference) it doesn't need to be called in a setter chain (e.g. `a.b.c = 0`) since it will be updated in place. This commit adds an instruction that jumps when the value is shared so it can be used to skip those cases and avoid redundant calls of setters. It also solves issues when assigning to sub-properties of read-only properties.
2022-06-27 17:09:51 +02:00
static bool is_type_shared(Variant::Type p_type);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Rename Variant::is_ref() to is_ref_counted()
2021-08-26 21:37:17 +02:00
bool is_ref_counted() 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 22:01:26 +01: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 19:20:53 +01: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 15:46:49 +02:00
}
Rework blending method in Variant animation for Int/Array/String
2023-11-10 13:29:45 +01:00
_FORCE_INLINE_ bool is_string() const {
return type == STRING || type == STRING_NAME;
}
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 22:01:26 +01: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 15:46:49 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 05:29:49 +02:00
bool is_one() const;
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 20:03:10 +01:00
bool is_null() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Make sure Variant is not implicitely cast when using operator[] Co-authored-by: Hein-Pieter van Braam-Stewart <hp@tmm.cx>
2021-06-09 21:11:06 +02:00
// Make sure Variant is not implicitly cast when accessing it with bracket notation (GH-49469).
Variant &operator[](const Variant &p_key) = delete;
const Variant &operator[](const Variant &p_key) const = delete;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 18:24:06 +01:00
operator ObjectID() const;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +02:00
operator char32_t() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
operator Vector2i() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
operator Rect2i() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
operator Vector3i() const;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
operator Vector4() const;
operator Vector4i() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
operator Plane() const;
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 03:09:00 +01:00
operator ::AABB() const;
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
operator Quaternion() const;
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 04:52:51 +01:00
operator Basis() const;
operator Transform2D() const;
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 09:36:08 +02:00
operator Transform3D() const;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
operator Projection() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 14:53:05 +01:00
operator ::RID() const;
Removal of InputEvent as built-in Variant type.. this might cause bugs I haven't found yet..
2017-05-20 17:38:03 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
operator Object *() const;
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
operator Callable() const;
operator Signal() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
operator Dictionary() const;
operator Array() const;
remove trailing whitespace
2016-03-09 00:00:52 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 19:20:53 +01: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 02:10:30 +01: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 22:06:54 +01: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 14:53:05 +01:00
operator Vector<::RID>() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
operator Vector<Vector2>() const;
// some core type enums to convert to
Rename Control margin to offset
2020-12-22 17:24:29 +01:00
operator Side() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
operator Orientation() const;
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
operator IPAddress() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 20:03:10 +01: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 02:43:10 +02:00
Variant(bool p_bool);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 15:08:25 +02:00
Variant(int64_t p_int); // real one
Variant(uint64_t p_int);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 18:24:06 +01:00
Variant(const ObjectID &p_id);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 12:43:20 +02:00
Variant(const char32_t *p_wstring);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
Variant(const Vector2i &p_vector2i);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
Variant(const Rect2i &p_rect2i);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 04:26:41 +01:00
Variant(const Vector3i &p_vector3i);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
Variant(const Vector4 &p_vector4);
Variant(const Vector4i &p_vector4i);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant(const Plane &p_plane);
Rename Rect3 to AABB. Fixes #12973.
2017-11-17 03:09:00 +01:00
Variant(const ::AABB &p_aabb);
Rename Quat to Quaternion
2021-01-20 08:02:02 +01:00
Variant(const Quaternion &p_quat);
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02:00
Variant(const Basis &p_matrix);
Type renames: Matrix32 -> Transform2D Matrix3 -> Basis AABB -> Rect3 RawArray -> PoolByteArray IntArray -> PoolIntArray FloatArray -> PoolFloatArray Vector2Array -> PoolVector2Array Vector3Array -> PoolVector3Array ColorArray -> PoolColorArray
2017-01-11 04:52:51 +01:00
Variant(const Transform2D &p_transform);
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Variant(const Transform3D &p_transform);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-20 01:11:13 +02:00
Variant(const Projection &p_projection);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant(const Color &p_color);
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02: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 14:53:05 +01:00
Variant(const ::RID &p_rid);
remove trailing whitespace
2016-03-09 00:00:52 +01:00
Variant(const Object *p_object);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
Variant(const Callable &p_callable);
Variant(const Signal &p_signal);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant(const Dictionary &p_dictionary);
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 16:44:50 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
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 22:06:54 +01: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 19:20:53 +01: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 22:06:54 +01: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 16:44:50 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant(const Vector<Variant> &p_array);
Some code changed with Clang-Tidy
2019-06-26 15:08:25 +02: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 14:53:05 +01:00
Variant(const Vector<::RID> &p_array); // helper
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant(const Vector<Vector2> &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 16:44:50 +01:00
Rename `IP_Unix`, `IP_Address` and `TCP_Server` to remove underscores
2021-05-06 02:48:18 +02:00
Variant(const IPAddress &p_address);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Use "enum class" for input enums
2021-08-13 23:31:57 +02:00
#define VARIANT_ENUM_CLASS_CONSTRUCTOR(m_enum) \
Don't use a const reference for the enum constructor in Variant
2022-10-17 01:52:54 +02:00
Variant(m_enum p_value) { \
Use "enum class" for input enums
2021-08-13 23:31:57 +02:00
type = INT; \
_data._int = (int64_t)p_value; \
}
// Only enum classes that need to be bound need this to be defined.
Unify Node3D RotationOrder with global EulerOrder
2022-10-02 04:53:46 +02:00
VARIANT_ENUM_CLASS_CONSTRUCTOR(EulerOrder)
Use "enum class" for input enums
2021-08-13 23:31:57 +02:00
VARIANT_ENUM_CLASS_CONSTRUCTOR(JoyAxis)
VARIANT_ENUM_CLASS_CONSTRUCTOR(JoyButton)
VARIANT_ENUM_CLASS_CONSTRUCTOR(Key)
VARIANT_ENUM_CLASS_CONSTRUCTOR(MIDIMessage)
VARIANT_ENUM_CLASS_CONSTRUCTOR(MouseButton)
#undef VARIANT_ENUM_CLASS_CONSTRUCTOR
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 02:32:05 +02:00
// If this changes the table in variant_op must be updated
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 17:30:55 +01:00
//comparison
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 02:32:05 +02:00
OP_SUBTRACT,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
OP_MULTIPLY,
OP_DIVIDE,
OP_NEGATE,
Added small modification on parser for '+'
2016-10-12 23:43:59 +02:00
OP_POSITIVE,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
OP_MODULE,
Implement exponential operator (**) to GDScript/Expressions
2022-03-07 18:25:21 +01:00
OP_POWER,
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
//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);
static void evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b, Variant &r_ret, bool &r_valid);
Small Fixes -=-=-=-=-=- -Bug in navmesh demo fixed -Bug in variant -Better Collada Exporter supports proper names of exported shapekeys
2014-12-08 19:47:45 +01:00
static _FORCE_INLINE_ Variant evaluate(const Operator &p_op, const Variant &p_a, const Variant &p_b) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
bool valid = true;
Variant res;
evaluate(p_op, p_a, p_b, res, valid);
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 18:11:15 +01: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 03:01:55 +01: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 04:34:49 +01:00
void zero();
Modify Dictionary::operator== to do real key/value comparison with recursive support (and add unittests)
2020-02-01 07:04:14 +01:00
Variant duplicate(bool p_deep = false) const;
Variant recursive_duplicate(bool p_deep, int recursion_count) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 17:16:08 +01: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 20:59:37 +02: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 17:16:08 +01: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 20:59:37 +02: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 17:16:08 +01: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 20:59:37 +02: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 17:16:08 +01: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 14:56:34 +01: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 17:16:08 +01: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 15:09:06 +01:00
static int get_builtin_method_count(Variant::Type p_type);
Implement native extension system * Deprecates GDNative in favor of a simpler, lower level interface. * New extension system allows registering core engine classes. * Simple header interface in gdnative_interace.h
2021-06-19 17:58:49 +02:00
static uint32_t get_builtin_method_hash(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 20:59:37 +02:00
Remove VARIANT_ARG* macros * Very old macros from the time Godot was created. * Limited arguments to 5 (then later changed to 8) in many places. * They were replaced by C++11 Variadic Templates. * Renamed methods that take argument pointers to have a "p" suffix. This was used in some places and not in others, so made it standard. * Also added a dereference check for Variant*. Helped catch a couple of bugs.
2022-03-09 14:58:40 +01:00
void callp(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error);
template <typename... VarArgs>
Variant call(const StringName &p_method, VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
Callable::CallError cerr;
Variant ret;
callp(p_method, sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args), ret, cerr);
if (cerr.error != Callable::CallError::CALL_OK) {
_variant_call_error(p_method, cerr);
}
return ret;
}
-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 13:35:21 +01:00
Add a const call mode to Object, Variant and Script. For this to work safely (user not call queue_free or something in the expression), a const call mode was added to Object and Variant (and optionally Script). This mode ensures only const functions can be called, making it safe to use from the editor. Co-Authored-By: reduz <reduzio@gmail.com>
2022-06-27 22:10:04 +02:00
void call_const(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error);
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 14:56:34 +01: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 22:31:33 +01: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 20:27:19 +01: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 13:35:21 +01: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 17:16:08 +01: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 21:12:02 +01:00
typedef void (*ValidatedConstructor)(Variant *r_base, const Variant **p_args);
Refactored variant constructor logic
2020-11-09 04:19:09 +01: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 02:10:30 +01:00
Improve extension system - Fix library loading and initialization. - Add extra methods/parameters in the interface needed by extenstions. - Add Variant destructors and functions for extracting values and creating Variants from values.
2021-07-29 15:53:05 +02:00
/* Destructors */
// Only ptrcall is available.
typedef void (*PTRDestructor)(void *base);
static PTRDestructor get_ptr_destructor(Variant::Type p_type);
static bool has_destructor(Variant::Type p_type);
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 17:16:08 +01:00
/* Properties */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 02:29:22 +01: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 15:09:06 +01: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 02:29:22 +01: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 17:16:08 +01: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 02:29:22 +01:00
static bool has_indexing(Variant::Type p_type);
static Variant::Type get_indexed_element_type(Variant::Type p_type);
Add property usage to array indexer This makes the `Array` indexer show as returning `Variant` instead of `void` in the documentation.
2023-01-18 21:57:47 +01:00
static uint32_t get_indexed_element_usage(Variant::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 02:29:22 +01:00
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 21:12:02 +01: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 02:29:22 +01: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 17:16:08 +01: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 02:29:22 +01: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 21:12:02 +01: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 02:29:22 +01: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);
Implement native extension system * Deprecates GDNative in favor of a simpler, lower level interface. * New extension system allows registering core engine classes. * Simple header interface in gdnative_interace.h
2021-06-19 17:58:49 +02:00
typedef uint32_t (*PTRKeyedChecker)(const void *base, const void *key);
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 02:29:22 +01:00
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 02:10:30 +01: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 17:16:08 +01:00
/* Generic */
Replace NULL with nullptr
2020-04-02 01:20:12 +02: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 02:10:30 +01: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;
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 17:16:08 +01: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 22:31:33 +01: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 17:16:08 +01: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 22:31:33 +01: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 17:16:08 +01: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 22:31:33 +01: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 17:16:08 +01: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 22:31:33 +01: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 17:16:08 +01: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 22:31:33 +01:00
Fix autocompletion of built-in functions in GDScript
2021-10-10 21:22:07 +02:00
static MethodInfo get_utility_function_info(const StringName &p_name);
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 17:16:08 +01: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);
Implement native extension system * Deprecates GDNative in favor of a simpler, lower level interface. * New extension system allows registering core engine classes. * Simple header interface in gdnative_interace.h
2021-06-19 17:58:49 +02:00
static uint32_t get_utility_function_hash(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 22:31:33 +01: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 17:16:08 +01: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 15:09:06 +01: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 22:31:33 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
//argsVariant call()
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
bool operator==(const Variant &p_variant) const;
-Ability to roll-back script-exported properties to their default value on the script, closes #2128
2016-01-03 00:17:31 +01:00
bool operator!=(const Variant &p_variant) const;
Sort xml files, so order is constant Makes xml format work better with version control systems.
2015-05-01 02:53:41 +02:00
bool operator<(const Variant &p_variant) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
uint32_t hash() const;
Modify Dictionary::operator== to do real key/value comparison with recursive support (and add unittests)
2020-02-01 07:04:14 +01:00
uint32_t recursive_hash(int recursion_count) const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Support both semantic (by default) and numeric Variant hash comparison Hash comparison for Variant continues to perform semantic/logical comparison with NaN's considered equal by default (to prevent #16114, #7354, #6947, #8081), but now optionally allows for numeric comparison that does not consider NaN's equal to support proper value comparison (for #72222)
2023-03-08 04:13:00 +01:00
// By default, performs a semantic comparison. Otherwise, numeric/binary comparison (if appropriate).
bool hash_compare(const Variant &p_variant, int recursion_count = 0, bool semantic_comparison = true) const;
Add `@GlobalScope` `is_same(a, b)` and `Variant::identity_compare()`
2023-01-20 20:36:52 +01:00
bool identity_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 20:02:47 +02:00
bool booleanize() const;
Modify Dictionary::operator== to do real key/value comparison with recursive support (and add unittests)
2020-02-01 07:04:14 +01:00
String stringify(int recursion_count = 0) const;
Consolidate JSON, JSONParseResults and JSONParser into JSON Renames JSON.parse_string() to parse() Renames JSON.decode_data() to stringify()
2020-12-29 19:12:33 +01:00
String to_json_string() const;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void static_assign(const Variant &p_variant);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01: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 15:09:06 +01:00
static int get_constants_count_for_type(Variant::Type p_type);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
static bool has_constant(Variant::Type p_type, const StringName &p_value);
Replace NULL with nullptr
2020-04-02 01:20:12 +02: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 02:10:30 +01:00
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
static void get_enums_for_type(Variant::Type p_type, List<StringName> *p_enums);
static void get_enumerations_for_enum(Variant::Type p_type, StringName p_enum_name, List<StringName> *p_enumerations);
static int get_enum_value(Variant::Type p_type, StringName p_enum_name, StringName p_enumeration, bool *r_valid = nullptr);
begin new serialization framework also got rid of STL dependency on triangulator
2015-02-15 05:19:46 +01:00
typedef String (*ObjectDeConstruct)(const Variant &p_object, void *ud);
typedef void (*ObjectConstruct)(const String &p_text, void *ud, Variant &r_value);
-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 04:54:00 +01:00
String get_construct_string() const;
Replace NULL with nullptr
2020-04-02 01:20:12 +02: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 02:10:30 +01: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 17:01:17 +02:00
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
static void register_types();
static void unregister_types();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 17:01:17 +02:00
_FORCE_INLINE_ Variant() {}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_FORCE_INLINE_ ~Variant() {
Refactored variant constructor logic
2020-11-09 04:19:09 +01: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 16:44:50 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
//typedef Dictionary Dictionary; no
//typedef Array Array;
Vector<Variant> varray();
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);
struct VariantHasher {
static _FORCE_INLINE_ uint32_t hash(const Variant &p_variant) { return p_variant.hash(); }
};
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 14:41:16 +01:00
struct VariantComparator {
static _FORCE_INLINE_ bool compare(const Variant &p_lhs, const Variant &p_rhs) { return p_lhs.hash_compare(p_rhs); }
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Unify String and StringName
2022-12-06 03:46:47 +01:00
struct StringLikeVariantComparator {
static bool compare(const Variant &p_lhs, const Variant &p_rhs);
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant::ObjData &Variant::_get_obj() {
return *reinterpret_cast<ObjData *>(&_data._mem[0]);
}
const Variant::ObjData &Variant::_get_obj() const {
return *reinterpret_cast<const ObjData *>(&_data._mem[0]);
}
Use variadic template in `vformat()` Allows `vformat()` to take more than 5 arguments. as well as being a general optimisation that avoids redundant empty Variant checks.
2022-09-13 22:27:10 +02:00
template <typename... VarArgs>
String vformat(const String &p_text, const VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
Array args_array;
args_array.resize(sizeof...(p_args));
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
args_array[i] = args[i];
}
bool error = false;
String fmt = p_text.sprintf(args_array, &error);
ERR_FAIL_COND_V_MSG(error, String(), fmt);
return fmt;
}
Style: Harmonize header guards to style guide [Core]
2020-03-25 11:10:34 +01:00
Add vararg call() method to C++ Callable
2023-07-11 16:18:10 +02:00
template <typename... VarArgs>
Variant Callable::call(VarArgs... p_args) const {
Variant args[sizeof...(p_args) + 1] = { p_args..., 0 }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
Variant ret;
CallError ce;
callp(sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args), ret, ce);
return ret;
}
Remove Signal connect binds Remove the optional argument p_binds from `Object::connect` since it was deprecated by Callable.bind(). Changed all uses of it to Callable.bind()
2022-07-28 22:56:41 +02:00
template <typename... VarArgs>
Callable Callable::bind(VarArgs... p_args) {
Variant args[sizeof...(p_args) + 1] = { p_args..., Variant() }; // +1 makes sure zero sized arrays are also supported.
const Variant *argptrs[sizeof...(p_args) + 1];
for (uint32_t i = 0; i < sizeof...(p_args); i++) {
argptrs[i] = &args[i];
}
return bindp(sizeof...(p_args) == 0 ? nullptr : (const Variant **)argptrs, sizeof...(p_args));
}
Style: Harmonize header guards to style guide [Core]
2020-03-25 11:10:34 +01:00
#endif // VARIANT_H
Reference in a new issue Copy permalink