Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-10-19 16:03:29 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/core/variant/variant_call.cpp

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

3002 lines
174 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
/**************************************************************************/
/* variant_call.cpp */
/**************************************************************************/
/* 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-09 22:10:30 -03:00
#include "variant.h"
Style: Cleanups, added headers, renamed files Made sure files in core/ and tools/ have a proper Godot license header when written by us. Also renamed aabb.{cpp,h} and object_type_db.{cpp,h} to rect3.{cpp,h} and class_db.{cpp,h} respectively. Also added a proper header to core/io/base64.{c,h} after clarifying the licensing with the original author (public domain).
2017-01-16 08:04:19 +01:00
Move CryptoCore to it's own folder. Crypto classes will be placed in core/crypto.
2019-07-11 15:21:47 +02:00
#include "core/crypto/crypto_core.h"
Refactor ScriptDebugger. EngineDebugger is the new interface to access the debugger. It tries to be as agnostic as possible on the data that various subsystems can expose. It allows 2 types of interactions: - Profilers: A subsystem can register a profiler, assigning it a unique name. That name can be used to activate the profiler or add data to it. The registered profiler can be composed of up to 3 functions: - Toggle: called when the profiler is activated/deactivated. - Add: called whenever data is added to the debugger (via `EngineDebugger::profiler_add_frame_data`) - Tick: called every frame (during idle), receives frame times. - Captures: (Only relevant in remote debugger for now) A subsystem can register a capture, assigning it a unique name. When receiving a message, the remote debugger will check if it starts with `[prefix]:` and call the associated capture with name `prefix`. Port MultiplayerAPI, Servers, Scripts, Visual, Performance to the new profiler system. Port SceneDebugger and RemoteDebugger to the new capture system. The LocalDebugger also uses the new profiler system for scripts profiling.
2020-02-27 03:30:20 +01:00
#include "core/debugger/engine_debugger.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/compression.h"
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
#include "core/io/marshalls.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 19:33:38 -03:00
#include "core/object/class_db.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/os/os.h"
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
#include "core/templates/a_hash_map.h"
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 13:16:08 -03:00
#include "core/templates/local_vector.h"
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
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 10:56:34 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ void vc_static_method_call(R (*method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_static_ret_dv(method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename... P>
static _FORCE_INLINE_ void vc_static_method_call(void (*method)(P...), const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_static_dv(method, p_args, p_argcount, r_error, p_defvals);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_ret_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
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 15:59:37 -03: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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_retc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
GDScript: Error when assigning return value of void function This also makes built-in method calls empty the return value when the method is void, to avoid keeping returning a garbage value in such case.
2022-12-29 08:57:41 -03:00
VariantInternal::clear(&r_ret);
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 13:16:08 -03:00
call_with_variant_args_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
GDScript: Error when assigning return value of void function This also makes built-in method calls empty the return value when the method is void, to avoid keeping returning a garbage value in such case.
2022-12-29 08:57:41 -03:00
VariantInternal::clear(&r_ret);
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 13:16:08 -03:00
call_with_variant_argsc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, p_defvals);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_variant_args_ret_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_variant_args_retc_dv(&converted, method, p_args, p_argcount, r_ret, r_error, p_defvals);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_variant_args_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_method_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_variant_argsc_dv(&converted, method, p_args, p_argcount, r_error, p_defvals);
}
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call_static(R (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_retc_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, p_defvals, r_error);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_method_call_static(void (*method)(T *, P...), Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) {
call_with_variant_args_static_helper_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, p_defvals, r_error);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call(R (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_ret(base, method, p_args, r_ret);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_retc(base, method, p_args, r_ret);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call(void (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args(base, method, p_args);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_argsc(base, method, p_args);
}
Moved JSON functions to built-in to_json, parse_json, validate_json
2017-01-08 22:40:00 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_validated_variant_args_ret_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(R (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_validated_variant_args_retc_helper<T, R, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...), Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_validated_variant_args_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_validated_call(void (T::*method)(P...) const, Variant *base, const Variant **p_args, Variant *r_ret) {
T converted(static_cast<T>(*VariantGetInternalPtr<From>::get_ptr(base)));
call_with_validated_variant_argsc_helper<T, P...>(&converted, method, p_args, r_ret, BuildIndexSequence<sizeof...(P)>{});
}
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call_static(R (*method)(T *, P...), Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_static_retc(base, method, p_args, r_ret);
}
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_validated_call_static(void (*method)(T *, P...), Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_static(base, method, p_args);
}
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 10:56:34 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ void vc_validated_static_call(R (*method)(P...), const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_static_method_ret(method, p_args, r_ret);
}
template <typename... P>
static _FORCE_INLINE_ void vc_validated_static_call(void (*method)(P...), const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args_static_method(method, p_args);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(R (T::*method)(P...), void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_ret(reinterpret_cast<T *>(p_base), method, p_args, r_ret);
}
Moved JSON functions to built-in to_json, parse_json, validate_json
2017-01-08 22:40:00 -03: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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(R (T::*method)(P...) const, void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_retc(reinterpret_cast<T *>(p_base), method, p_args, r_ret);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(void (T::*method)(P...), void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args(reinterpret_cast<T *>(p_base), method, p_args);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(void (T::*method)(P...) const, void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_argsc(reinterpret_cast<T *>(p_base), method, p_args);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_ptrcall(R (T::*method)(P...), void *p_base, const void **p_args, void *r_ret) {
T converted(*reinterpret_cast<From *>(p_base));
call_with_ptr_args_ret(&converted, method, p_args, r_ret);
}
template <typename From, typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_ptrcall(R (T::*method)(P...) const, void *p_base, const void **p_args, void *r_ret) {
T converted(*reinterpret_cast<From *>(p_base));
call_with_ptr_args_retc(&converted, method, p_args, r_ret);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_ptrcall(void (T::*method)(P...), void *p_base, const void **p_args, void *r_ret) {
T converted(*reinterpret_cast<From *>(p_base));
call_with_ptr_args(&converted, method, p_args);
}
template <typename From, typename T, typename... P>
static _FORCE_INLINE_ void vc_convert_ptrcall(void (T::*method)(P...) const, void *p_base, const void **p_args, void *r_ret) {
T converted(*reinterpret_cast<From *>(p_base));
call_with_ptr_argsc(&converted, method, p_args);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count(R (T::*method)(P...)) {
return sizeof...(P);
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count(R (T::*method)(P...) const) {
return sizeof...(P);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count(void (T::*method)(P...)) {
return sizeof...(P);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count(void (T::*method)(P...) const) {
return sizeof...(P);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count(R (*method)(T *, P...)) {
return sizeof...(P);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ int vc_get_argument_count_static(R (*method)(P...)) {
return sizeof...(P);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type(R (T::*method)(P...), int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type(R (T::*method)(P...) const, int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type(void (T::*method)(P...), int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type(void (T::*method)(P...) const, int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type(R (*method)(T *, P...), int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +02:00
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_argument_type_static(R (*method)(P...), int p_arg) {
return call_get_argument_type<P...>(p_arg);
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(R (T::*method)(P...)) {
return GetTypeInfo<R>::VARIANT_TYPE;
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(R (T::*method)(P...) const) {
return GetTypeInfo<R>::VARIANT_TYPE;
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(void (T::*method)(P...)) {
return Variant::NIL;
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(void (T::*method)(P...) const) {
return Variant::NIL;
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03: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 13:16:08 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(R (*method)(P...)) {
return GetTypeInfo<R>::VARIANT_TYPE;
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
template <typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_return_type(void (*method)(P...)) {
return Variant::NIL;
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ bool vc_has_return_type(R (T::*method)(P...)) {
return true;
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ bool vc_has_return_type(R (T::*method)(P...) const) {
return true;
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ bool vc_has_return_type(void (T::*method)(P...)) {
return false;
}
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ bool vc_has_return_type(void (T::*method)(P...) const) {
return false;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
template <typename... P>
static _FORCE_INLINE_ bool vc_has_return_type_static(void (*method)(P...)) {
return false;
}
template <typename R, typename... P>
static _FORCE_INLINE_ bool vc_has_return_type_static(R (*method)(P...)) {
return true;
}
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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ bool vc_is_const(R (T::*method)(P...)) {
return false;
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ bool vc_is_const(R (T::*method)(P...) const) {
return true;
}
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 15:59:37 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ bool vc_is_const(void (T::*method)(P...)) {
return false;
}
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 15:59:37 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ bool vc_is_const(void (T::*method)(P...) const) {
return true;
}
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 15:59:37 -03: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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_base_type(R (T::*method)(P...)) {
return GetTypeInfo<T>::VARIANT_TYPE;
}
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_base_type(R (T::*method)(P...) const) {
return GetTypeInfo<T>::VARIANT_TYPE;
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 15:59:37 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_base_type(void (T::*method)(P...)) {
return GetTypeInfo<T>::VARIANT_TYPE;
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ Variant::Type vc_get_base_type(void (T::*method)(P...) const) {
return GetTypeInfo<T>::VARIANT_TYPE;
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 15:59:37 -03: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 13:16:08 -03:00
#define METHOD_CLASS(m_class, m_method_name, m_method_ptr) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
vc_method_call(m_method_ptr, base, p_args, p_argcount, r_ret, p_defvals, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
vc_validated_call(m_method_ptr, base, p_args, r_ret); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
vc_ptrcall(m_method_ptr, p_base, p_args, r_ret); \
} \
static int get_argument_count() { \
return vc_get_argument_count(m_method_ptr); \
} \
static Variant::Type get_argument_type(int p_arg) { \
return vc_get_argument_type(m_method_ptr, p_arg); \
} \
static Variant::Type get_return_type() { \
return vc_get_return_type(m_method_ptr); \
} \
static bool has_return_type() { \
return vc_has_return_type(m_method_ptr); \
} \
static bool is_const() { \
return vc_is_const(m_method_ptr); \
} \
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 10:56:34 -03:00
static bool is_static() { \
return false; \
} \
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 13:16:08 -03:00
static bool is_vararg() { \
return false; \
} \
static Variant::Type get_base_type() { \
return vc_get_base_type(m_method_ptr); \
} \
static StringName get_name() { \
return #m_method_name; \
} \
};
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 15:59:37 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
#define CONVERT_METHOD_CLASS(m_class, m_method_name, m_method_ptr) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
vc_convert_method_call<m_class>(m_method_ptr, base, p_args, p_argcount, r_ret, p_defvals, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
vc_convert_validated_call<m_class>(m_method_ptr, base, p_args, r_ret); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
vc_convert_ptrcall<m_class>(m_method_ptr, p_base, p_args, r_ret); \
} \
static int get_argument_count() { \
return vc_get_argument_count(m_method_ptr); \
} \
static Variant::Type get_argument_type(int p_arg) { \
return vc_get_argument_type(m_method_ptr, p_arg); \
} \
static Variant::Type get_return_type() { \
return vc_get_return_type(m_method_ptr); \
} \
static bool has_return_type() { \
return vc_has_return_type(m_method_ptr); \
} \
static bool is_const() { \
return vc_is_const(m_method_ptr); \
} \
static bool is_static() { \
return false; \
} \
static bool is_vararg() { \
return false; \
} \
static Variant::Type get_base_type() { \
return GetTypeInfo<m_class>::VARIANT_TYPE; \
} \
static StringName get_name() { \
return #m_method_name; \
} \
};
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 10:56:34 -03:00
template <typename R, typename... P>
static _FORCE_INLINE_ void vc_static_ptrcall(R (*method)(P...), const void **p_args, void *r_ret) {
call_with_ptr_args_static_method_ret<R, P...>(method, p_args, r_ret);
}
template <typename... P>
static _FORCE_INLINE_ void vc_static_ptrcall(void (*method)(P...), const void **p_args, void *r_ret) {
call_with_ptr_args_static_method<P...>(method, p_args);
}
#define STATIC_METHOD_CLASS(m_class, m_method_name, m_method_ptr) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
vc_static_method_call(m_method_ptr, p_args, p_argcount, r_ret, p_defvals, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
vc_validated_static_call(m_method_ptr, p_args, r_ret); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
vc_static_ptrcall(m_method_ptr, p_args, r_ret); \
} \
static int get_argument_count() { \
return vc_get_argument_count_static(m_method_ptr); \
} \
static Variant::Type get_argument_type(int p_arg) { \
return vc_get_argument_type_static(m_method_ptr, p_arg); \
} \
static Variant::Type get_return_type() { \
return vc_get_return_type(m_method_ptr); \
} \
static bool has_return_type() { \
return vc_has_return_type_static(m_method_ptr); \
} \
static bool is_const() { \
return false; \
} \
static bool is_static() { \
return true; \
} \
static bool is_vararg() { \
return false; \
} \
static Variant::Type get_base_type() { \
return GetTypeInfo<m_class>::VARIANT_TYPE; \
} \
static StringName get_name() { \
return #m_method_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 13:16:08 -03:00
template <typename R, typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(R (*method)(T *, P...), void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_static_retc<T, R, P...>(reinterpret_cast<T *>(p_base), method, p_args, r_ret);
}
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 15:59:37 -03:00
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
template <typename T, typename... P>
static _FORCE_INLINE_ void vc_ptrcall(void (*method)(T *, P...), void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_static<T, P...>(reinterpret_cast<T *>(p_base), method, p_args);
}
#define FUNCTION_CLASS(m_class, m_method_name, m_method_ptr, m_const) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
vc_method_call_static(m_method_ptr, base, p_args, p_argcount, r_ret, p_defvals, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
vc_validated_call_static(m_method_ptr, base, p_args, r_ret); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
vc_ptrcall(m_method_ptr, p_base, p_args, r_ret); \
} \
static int get_argument_count() { \
return vc_get_argument_count(m_method_ptr); \
} \
static Variant::Type get_argument_type(int p_arg) { \
return vc_get_argument_type(m_method_ptr, p_arg); \
} \
static Variant::Type get_return_type() { \
return vc_get_return_type(m_method_ptr); \
} \
static bool has_return_type() { \
return vc_has_return_type_static(m_method_ptr); \
} \
static bool is_const() { \
return m_const; \
} \
static bool is_static() { \
return false; \
} \
static bool is_vararg() { \
return false; \
} \
static Variant::Type get_base_type() { \
return GetTypeInfo<m_class>::VARIANT_TYPE; \
} \
static StringName get_name() { \
return #m_method_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 13:16:08 -03:00
};
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 15:59:37 -03: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 13:16:08 -03:00
#define VARARG_CLASS(m_class, m_method_name, m_method_ptr, m_has_return, m_return_type) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
m_method_ptr(base, p_args, p_argcount, r_ret, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
Callable::CallError ce; \
m_method_ptr(base, p_args, p_argcount, *r_ret, ce); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
LocalVector<Variant> vars; \
LocalVector<const Variant *> vars_ptrs; \
Set builtin varrarg ptrcalls, called without arg.
2023-04-14 15:42:03 +08:00
vars.resize(p_argcount); \
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 13:16:08 -03:00
vars_ptrs.resize(p_argcount); \
for (int i = 0; i < p_argcount; i++) { \
vars[i] = PtrToArg<Variant>::convert(p_args[i]); \
vars_ptrs[i] = &vars[i]; \
} \
Variant base = PtrToArg<m_class>::convert(p_base); \
Variant ret; \
Callable::CallError ce; \
Set builtin varrarg ptrcalls, called without arg.
2023-04-14 15:42:03 +08:00
m_method_ptr(&base, vars_ptrs.ptr(), p_argcount, ret, ce); \
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 13:16:08 -03:00
if (m_has_return) { \
m_return_type r = ret; \
PtrToArg<m_return_type>::encode(ret, r_ret); \
} \
} \
static int get_argument_count() { \
return 0; \
} \
static Variant::Type get_argument_type(int p_arg) { \
return Variant::NIL; \
} \
static Variant::Type get_return_type() { \
return GetTypeInfo<m_return_type>::VARIANT_TYPE; \
} \
static bool has_return_type() { \
return m_has_return; \
} \
static bool is_const() { \
return true; \
} \
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 10:56:34 -03:00
static bool is_static() { \
return false; \
} \
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 13:16:08 -03:00
static bool is_vararg() { \
return true; \
} \
static Variant::Type get_base_type() { \
return GetTypeInfo<m_class>::VARIANT_TYPE; \
} \
static StringName get_name() { \
return #m_method_name; \
} \
};
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 15:59:37 -03:00
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
#define VARARG_CLASS1(m_class, m_method_name, m_method_ptr, m_arg_type) \
struct Method_##m_class##_##m_method_name { \
static void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) { \
m_method_ptr(base, p_args, p_argcount, r_ret, r_error); \
} \
static void validated_call(Variant *base, const Variant **p_args, int p_argcount, Variant *r_ret) { \
Callable::CallError ce; \
m_method_ptr(base, p_args, p_argcount, *r_ret, ce); \
} \
static void ptrcall(void *p_base, const void **p_args, void *r_ret, int p_argcount) { \
LocalVector<Variant> vars; \
LocalVector<const Variant *> vars_ptrs; \
Set builtin varrarg ptrcalls, called without arg.
2023-04-14 15:42:03 +08:00
vars.resize(p_argcount); \
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
vars_ptrs.resize(p_argcount); \
for (int i = 0; i < p_argcount; i++) { \
vars[i] = PtrToArg<Variant>::convert(p_args[i]); \
vars_ptrs[i] = &vars[i]; \
} \
Variant base = PtrToArg<m_class>::convert(p_base); \
Variant ret; \
Callable::CallError ce; \
Set builtin varrarg ptrcalls, called without arg.
2023-04-14 15:42:03 +08:00
m_method_ptr(&base, vars_ptrs.ptr(), p_argcount, ret, ce); \
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
} \
static int get_argument_count() { \
return 1; \
} \
static Variant::Type get_argument_type(int p_arg) { \
return m_arg_type; \
} \
static Variant::Type get_return_type() { \
return Variant::NIL; \
} \
static bool has_return_type() { \
return false; \
} \
static bool is_const() { \
return true; \
} \
static bool is_static() { \
return false; \
} \
static bool is_vararg() { \
return true; \
} \
static Variant::Type get_base_type() { \
return GetTypeInfo<m_class>::VARIANT_TYPE; \
} \
static StringName get_name() { \
return #m_method_name; \
} \
};
Add bound checks to `Array`/`Packed*Array` variant call `get` and `set` methods.
2025-02-27 17:43:40 +02:00
#define VARCALL_ARRAY_GETTER_SETTER(m_packed_type, m_type) \
static m_type func_##m_packed_type##_get(m_packed_type *p_instance, int64_t p_index) { \
ERR_FAIL_INDEX_V(p_index, p_instance->size(), m_type()); \
return p_instance->get(p_index); \
} \
static void func_##m_packed_type##_set(m_packed_type *p_instance, int64_t p_index, const m_type &p_value) { \
ERR_FAIL_INDEX(p_index, p_instance->size()); \
p_instance->set(p_index, p_value); \
Bind Array get and set functions
2024-08-21 19:26:21 -07: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 13:16:08 -03:00
struct _VariantCall {
Add bound checks to `Array`/`Packed*Array` variant call `get` and `set` methods.
2025-02-27 17:43:40 +02:00
VARCALL_ARRAY_GETTER_SETTER(PackedByteArray, uint8_t)
VARCALL_ARRAY_GETTER_SETTER(PackedColorArray, Color)
VARCALL_ARRAY_GETTER_SETTER(PackedFloat32Array, float)
VARCALL_ARRAY_GETTER_SETTER(PackedFloat64Array, double)
VARCALL_ARRAY_GETTER_SETTER(PackedInt32Array, int32_t)
VARCALL_ARRAY_GETTER_SETTER(PackedInt64Array, int64_t)
VARCALL_ARRAY_GETTER_SETTER(PackedStringArray, String)
VARCALL_ARRAY_GETTER_SETTER(PackedVector2Array, Vector2)
VARCALL_ARRAY_GETTER_SETTER(PackedVector3Array, Vector3)
VARCALL_ARRAY_GETTER_SETTER(PackedVector4Array, Vector4)
VARCALL_ARRAY_GETTER_SETTER(Array, Variant)
Bind Array get and set functions
2024-08-21 19:26:21 -07:00
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 15:59:37 -03:00
static String func_PackedByteArray_get_string_from_ascii(PackedByteArray *p_instance) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String s;
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 15:59:37 -03:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
CharString cs;
Rename `String::resize` to `resize_uninitialized`, to better communicate to callers that new characters must be initialized.
2025-05-28 20:33:21 +02:00
cs.resize_uninitialized(p_instance->size() + 1);
Core: Drop custom `copymem`/`zeromem` defines We've been using standard C library functions `memcpy`/`memset` for these since 2016 with 67f65f66391327b2967a20a89c3627e1dd6e84eb. There was still the possibility for third-party platform ports to override the definitions with a custom header, but this doesn't seem useful anymore.
2021-04-27 16:19:21 +02:00
memcpy(cs.ptrw(), r, p_instance->size());
Promote CowData to 64 bits Fixes a lot of bugs, please help me fill the list.
2024-01-03 01:14:50 +01:00
cs[(int)p_instance->size()] = 0;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
s = cs.get_data();
}
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 15:59:37 -03:00
return s;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Add bswap methods to the `PackedByteArray` bindings.
2025-04-08 10:39:29 +03:00
static void func_PackedByteArray_bswap16(PackedByteArray *p_instance, int64_t p_offset, int64_t p_count) {
size_t sz = p_instance->size();
if (sz == 0 || p_count == 0) {
return;
}
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(sz) - 2);
if (p_count < 0) {
p_count = floor((sz - p_offset) / 2);
}
ERR_FAIL_COND(p_count > floor((sz - p_offset) / 2));
uint16_t *w = (uint16_t *)(p_instance->ptrw() + p_offset);
for (int64_t i = 0; i < p_count; i++) {
w[i] = BSWAP16(w[i]);
}
}
static void func_PackedByteArray_bswap32(PackedByteArray *p_instance, int64_t p_offset, int64_t p_count) {
size_t sz = p_instance->size();
if (sz == 0 || p_count == 0) {
return;
}
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(sz) - 4);
if (p_count < 0) {
p_count = floor((sz - p_offset) / 4);
}
ERR_FAIL_COND(p_count > floor((sz - p_offset) / 4));
uint32_t *w = (uint32_t *)(p_instance->ptrw() + p_offset);
for (int64_t i = 0; i < p_count; i++) {
w[i] = BSWAP32(w[i]);
}
}
static void func_PackedByteArray_bswap64(PackedByteArray *p_instance, int64_t p_offset, int64_t p_count) {
size_t sz = p_instance->size();
if (sz == 0 || p_count == 0) {
return;
}
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(sz) - 8);
if (p_count < 0) {
p_count = floor((sz - p_offset) / 8);
}
ERR_FAIL_COND(p_count > floor((sz - p_offset) / 8));
uint64_t *w = (uint64_t *)(p_instance->ptrw() + p_offset);
for (int64_t i = 0; i < p_count; i++) {
w[i] = BSWAP64(w[i]);
}
}
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 15:59:37 -03:00
static String func_PackedByteArray_get_string_from_utf8(PackedByteArray *p_instance) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
String s;
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 15:59:37 -03:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
Use `append_` instead of `parse_` for `String` methods.
2025-03-24 12:25:48 +01:00
s.append_utf8((const char *)r, p_instance->size());
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
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 15:59:37 -03:00
return s;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
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 15:59:37 -03:00
static String func_PackedByteArray_get_string_from_utf16(PackedByteArray *p_instance) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
String s;
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 15:59:37 -03:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
Core: Replace C math headers with C++ equivalents - Minor restructuring to ensure `math_funcs.h` is the central point for math functions
2025-03-19 14:18:09 -05:00
s.append_utf16((const char16_t *)r, std::floor((double)p_instance->size() / (double)sizeof(char16_t)));
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
}
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 15:59:37 -03:00
return s;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
}
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 15:59:37 -03:00
static String func_PackedByteArray_get_string_from_utf32(PackedByteArray *p_instance) {
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
String s;
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 15:59:37 -03:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
Core: Replace C math headers with C++ equivalents - Minor restructuring to ensure `math_funcs.h` is the central point for math functions
2025-03-19 14:18:09 -05:00
s.append_utf32(Span((const char32_t *)r, std::floor((double)p_instance->size() / (double)sizeof(char32_t))));
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
}
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 15:59:37 -03:00
return s;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 13:43:20 +03:00
}
Add GDScript `to_wchar_buffer` and `get_string_from_wchar` functions.
2023-02-13 16:18:12 +02:00
static String func_PackedByteArray_get_string_from_wchar(PackedByteArray *p_instance) {
String s;
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
#ifdef WINDOWS_ENABLED
Core: Replace C math headers with C++ equivalents - Minor restructuring to ensure `math_funcs.h` is the central point for math functions
2025-03-19 14:18:09 -05:00
s.append_utf16((const char16_t *)r, std::floor((double)p_instance->size() / (double)sizeof(char16_t)));
Add GDScript `to_wchar_buffer` and `get_string_from_wchar` functions.
2023-02-13 16:18:12 +02:00
#else
Core: Replace C math headers with C++ equivalents - Minor restructuring to ensure `math_funcs.h` is the central point for math functions
2025-03-19 14:18:09 -05:00
s.append_utf32(Span((const char32_t *)r, std::floor((double)p_instance->size() / (double)sizeof(char32_t))));
Add GDScript `to_wchar_buffer` and `get_string_from_wchar` functions.
2023-02-13 16:18:12 +02:00
#endif
}
return s;
}
Add methods to decode/encode multibyte encodings.
2024-09-13 09:19:26 +03:00
static String func_PackedByteArray_get_string_from_multibyte_char(PackedByteArray *p_instance, const String &p_encoding) {
String s;
if (p_instance->size() > 0) {
s = OS::get_singleton()->multibyte_to_string(p_encoding, *p_instance);
}
return s;
}
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 15:59:37 -03:00
static PackedByteArray func_PackedByteArray_compress(PackedByteArray *p_instance, int p_mode) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 18:06:54 -03:00
PackedByteArray compressed;
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
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 15:59:37 -03:00
if (p_instance->size() > 0) {
Compression::Mode mode = (Compression::Mode)(p_mode);
compressed.resize(Compression::get_max_compressed_buffer_size(p_instance->size(), mode));
Support 64-bit sizes in Compression
2025-05-08 14:13:30 -07:00
int64_t result = Compression::compress(compressed.ptrw(), p_instance->ptr(), p_instance->size(), mode);
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
Don't use in some functions empty PoolByteArrays
2019-10-11 11:39:40 +02:00
result = result >= 0 ? result : 0;
compressed.resize(result);
}
Fixed PackedByteArray GDScript functions p_self._data.packed_array needs to be used instead of p_self._data._mem printline
2020-05-27 12:52:54 -07:00
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 15:59:37 -03:00
return compressed;
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
}
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 15:59:37 -03:00
static PackedByteArray func_PackedByteArray_decompress(PackedByteArray *p_instance, int64_t p_buffer_size, int p_mode) {
PoolVector is gone, replaced by Vector Typed `PoolTypeArray` types are now renamed `PackedTypeArray` and are sugar for `Vector<Type>`.
2020-02-17 18:06:54 -03:00
PackedByteArray decompressed;
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 15:59:37 -03:00
Compression::Mode mode = (Compression::Mode)(p_mode);
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
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 15:59:37 -03:00
int64_t buffer_size = p_buffer_size;
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
Fix decompress PoolByteArray crash
2019-10-10 17:15:10 +02:00
if (buffer_size <= 0) {
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 15:59:37 -03:00
ERR_FAIL_V_MSG(decompressed, "Decompression buffer size must be greater than zero.");
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
}
Return error when decompressing empty PoolByteArray
2021-05-25 18:43:26 +02:00
if (p_instance->size() == 0) {
ERR_FAIL_V_MSG(decompressed, "Compressed buffer size must be greater than zero.");
}
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
decompressed.resize(buffer_size);
Support 64-bit sizes in Compression
2025-05-08 14:13:30 -07:00
int64_t result = Compression::decompress(decompressed.ptrw(), buffer_size, p_instance->ptr(), p_instance->size(), mode);
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
result = result >= 0 ? result : 0;
decompressed.resize(result);
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 15:59:37 -03:00
return decompressed;
Add basic compression functions to PoolBaseArray
2017-06-19 02:46:29 -03:00
}
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 15:59:37 -03:00
static PackedByteArray func_PackedByteArray_decompress_dynamic(PackedByteArray *p_instance, int64_t p_buffer_size, int p_mode) {
HTTPRequest now accepts gzip Added request_raw to HttpRequest Added decompress_dynamic to Compression class Added decompress_dynamic to BytePoolArray Merge doc fix revert
2020-05-21 01:05:32 -07:00
PackedByteArray decompressed;
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 15:59:37 -03:00
int64_t max_output_size = p_buffer_size;
Compression::Mode mode = (Compression::Mode)(p_mode);
HTTPRequest now accepts gzip Added request_raw to HttpRequest Added decompress_dynamic to Compression class Added decompress_dynamic to BytePoolArray Merge doc fix revert
2020-05-21 01:05:32 -07:00
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 15:59:37 -03:00
int result = Compression::decompress_dynamic(&decompressed, max_output_size, p_instance->ptr(), p_instance->size(), mode);
HTTPRequest now accepts gzip Added request_raw to HttpRequest Added decompress_dynamic to Compression class Added decompress_dynamic to BytePoolArray Merge doc fix revert
2020-05-21 01:05:32 -07:00
if (result == OK) {
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 15:59:37 -03:00
return decompressed;
HTTPRequest now accepts gzip Added request_raw to HttpRequest Added decompress_dynamic to Compression class Added decompress_dynamic to BytePoolArray Merge doc fix revert
2020-05-21 01:05:32 -07:00
} else {
decompressed.clear();
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 15:59:37 -03:00
ERR_FAIL_V_MSG(decompressed, "Decompression failed.");
HTTPRequest now accepts gzip Added request_raw to HttpRequest Added decompress_dynamic to Compression class Added decompress_dynamic to BytePoolArray Merge doc fix revert
2020-05-21 01:05:32 -07:00
}
}
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 15:59:37 -03:00
static String func_PackedByteArray_hex_encode(PackedByteArray *p_instance) {
if (p_instance->size() == 0) {
return String();
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
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 15:59:37 -03:00
const uint8_t *r = p_instance->ptr();
String s = String::hex_encode_buffer(&r[0], p_instance->size());
return s;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
static int64_t func_PackedByteArray_decode_u8(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > int64_t(size) - 1, 0);
const uint8_t *r = p_instance->ptr();
return r[p_offset];
}
static int64_t func_PackedByteArray_decode_s8(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > int64_t(size) - 1, 0);
const uint8_t *r = p_instance->ptr();
return *((const int8_t *)&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_u16(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 2), 0);
const uint8_t *r = p_instance->ptr();
return decode_uint16(&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_s16(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 2), 0);
const uint8_t *r = p_instance->ptr();
return (int16_t)decode_uint16(&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_u32(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 4), 0);
const uint8_t *r = p_instance->ptr();
return decode_uint32(&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_s32(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 4), 0);
const uint8_t *r = p_instance->ptr();
return (int32_t)decode_uint32(&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_u64(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 8), 0);
const uint8_t *r = p_instance->ptr();
return (int64_t)decode_uint64(&r[p_offset]);
}
static int64_t func_PackedByteArray_decode_s64(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 8), 0);
const uint8_t *r = p_instance->ptr();
return (int64_t)decode_uint64(&r[p_offset]);
}
static double func_PackedByteArray_decode_half(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 2), 0);
const uint8_t *r = p_instance->ptr();
return Math::half_to_float(decode_uint16(&r[p_offset]));
}
static double func_PackedByteArray_decode_float(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 4), 0);
const uint8_t *r = p_instance->ptr();
return decode_float(&r[p_offset]);
}
static double func_PackedByteArray_decode_double(PackedByteArray *p_instance, int64_t p_offset) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0 || p_offset > (int64_t(size) - 8), 0);
const uint8_t *r = p_instance->ptr();
return decode_double(&r[p_offset]);
}
static bool func_PackedByteArray_has_encoded_var(PackedByteArray *p_instance, int64_t p_offset, bool p_allow_objects) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0, false);
const uint8_t *r = p_instance->ptr();
Variant ret;
Error err = decode_variant(ret, r + p_offset, size - p_offset, nullptr, p_allow_objects);
return err == OK;
}
static Variant func_PackedByteArray_decode_var(PackedByteArray *p_instance, int64_t p_offset, bool p_allow_objects) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0, Variant());
const uint8_t *r = p_instance->ptr();
Variant ret;
Error err = decode_variant(ret, r + p_offset, size - p_offset, nullptr, p_allow_objects);
if (err != OK) {
ret = Variant();
}
return ret;
}
static int64_t func_PackedByteArray_decode_var_size(PackedByteArray *p_instance, int64_t p_offset, bool p_allow_objects) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0, 0);
const uint8_t *r = p_instance->ptr();
Variant ret;
int r_size;
Error err = decode_variant(ret, r + p_offset, size - p_offset, &r_size, p_allow_objects);
if (err == OK) {
return r_size;
}
return 0;
}
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
static PackedInt32Array func_PackedByteArray_decode_s32_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedInt32Array dest;
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(int32_t), dest, "PackedByteArray size must be a multiple of 4 (size of 32-bit integer) to convert to PackedInt32Array.");
Fixed crash in `variant_call` when trying to memcpy 0 bytes.
2021-10-24 12:45:52 +02:00
const uint8_t *r = p_instance->ptr();
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
dest.resize(size / sizeof(int32_t));
Replace error checks against `size` with `is_empty`
2024-01-19 13:21:39 +01:00
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
memcpy(dest.ptrw(), r, dest.size() * sizeof(int32_t));
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
return dest;
}
static PackedInt64Array func_PackedByteArray_decode_s64_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedInt64Array dest;
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(int64_t), dest, "PackedByteArray size must be a multiple of 8 (size of 64-bit integer) to convert to PackedInt64Array.");
Fixed crash in `variant_call` when trying to memcpy 0 bytes.
2021-10-24 12:45:52 +02:00
const uint8_t *r = p_instance->ptr();
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
dest.resize(size / sizeof(int64_t));
Replace error checks against `size` with `is_empty`
2024-01-19 13:21:39 +01:00
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
memcpy(dest.ptrw(), r, dest.size() * sizeof(int64_t));
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
return dest;
}
static PackedFloat32Array func_PackedByteArray_decode_float_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedFloat32Array dest;
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(float), dest, "PackedByteArray size must be a multiple of 4 (size of 32-bit float) to convert to PackedFloat32Array.");
Fixed crash in `variant_call` when trying to memcpy 0 bytes.
2021-10-24 12:45:52 +02:00
const uint8_t *r = p_instance->ptr();
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
dest.resize(size / sizeof(float));
Replace error checks against `size` with `is_empty`
2024-01-19 13:21:39 +01:00
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
memcpy(dest.ptrw(), r, dest.size() * sizeof(float));
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
return dest;
}
static PackedFloat64Array func_PackedByteArray_decode_double_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedFloat64Array dest;
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(double), dest, "PackedByteArray size must be a multiple of 8 (size of 64-bit double) to convert to PackedFloat64Array.");
Fixed crash in `variant_call` when trying to memcpy 0 bytes.
2021-10-24 12:45:52 +02:00
const uint8_t *r = p_instance->ptr();
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
dest.resize(size / sizeof(double));
Replace error checks against `size` with `is_empty`
2024-01-19 13:21:39 +01:00
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
Prevent out-of-bounds write in array conversion; avoid logspam on empty arrays.
2022-06-27 19:02:42 -07:00
memcpy(dest.ptrw(), r, dest.size() * sizeof(double));
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
return dest;
}
Add PackedByteArray conversion to PackedVector2Array, PackedVector3Array, PackedVector4Array and PackedColorArray
2023-04-15 12:33:55 +03:00
static PackedVector2Array func_PackedByteArray_decode_vector2_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedVector2Array dest;
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(Vector2), dest, "PackedByteArray size must be a multiple of " + itos(sizeof(Vector2)) + " (size of Vector2) to convert to PackedVector2Array.");
const uint8_t *r = p_instance->ptr();
dest.resize(size / sizeof(Vector2));
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
memcpy(dest.ptrw(), r, dest.size() * sizeof(Vector2));
return dest;
}
static PackedVector3Array func_PackedByteArray_decode_vector3_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedVector3Array dest;
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(Vector3), dest, "PackedByteArray size must be a multiple of " + itos(sizeof(Vector3)) + " (size of Vector3) to convert to PackedVector3Array.");
const uint8_t *r = p_instance->ptr();
dest.resize(size / sizeof(Vector3));
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
memcpy(dest.ptrw(), r, dest.size() * sizeof(Vector3));
return dest;
}
static PackedVector4Array func_PackedByteArray_decode_vector4_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedVector4Array dest;
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(Vector4), dest, "PackedByteArray size must be a multiple of " + itos(sizeof(Vector4)) + " (size of Vector4) to convert to PackedVector4Array.");
const uint8_t *r = p_instance->ptr();
dest.resize(size / sizeof(Vector4));
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
memcpy(dest.ptrw(), r, dest.size() * sizeof(Vector4));
return dest;
}
static PackedColorArray func_PackedByteArray_decode_color_array(PackedByteArray *p_instance) {
uint64_t size = p_instance->size();
PackedColorArray dest;
if (size == 0) {
return dest;
}
ERR_FAIL_COND_V_MSG(size % sizeof(Color), dest, "PackedByteArray size must be a multiple of " + itos(sizeof(Color)) + " (size of Color variant) to convert to PackedColorArray.");
const uint8_t *r = p_instance->ptr();
dest.resize(size / sizeof(Color));
ERR_FAIL_COND_V(dest.is_empty(), dest); // Avoid UB in case resize failed.
memcpy(dest.ptrw(), r, dest.size() * sizeof(Color));
return dest;
}
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
static void func_PackedByteArray_encode_u8(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 1);
uint8_t *w = p_instance->ptrw();
*((uint8_t *)&w[p_offset]) = p_value;
}
static void func_PackedByteArray_encode_s8(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 1);
uint8_t *w = p_instance->ptrw();
*((int8_t *)&w[p_offset]) = p_value;
}
static void func_PackedByteArray_encode_u16(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 2);
uint8_t *w = p_instance->ptrw();
encode_uint16((uint16_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_s16(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 2);
uint8_t *w = p_instance->ptrw();
encode_uint16((int16_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_u32(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 4);
uint8_t *w = p_instance->ptrw();
encode_uint32((uint32_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_s32(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 4);
uint8_t *w = p_instance->ptrw();
encode_uint32((int32_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_u64(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 8);
uint8_t *w = p_instance->ptrw();
encode_uint64((uint64_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_s64(PackedByteArray *p_instance, int64_t p_offset, int64_t p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 8);
uint8_t *w = p_instance->ptrw();
encode_uint64((int64_t)p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_half(PackedByteArray *p_instance, int64_t p_offset, double p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 2);
uint8_t *w = p_instance->ptrw();
encode_uint16(Math::make_half_float(p_value), &w[p_offset]);
}
static void func_PackedByteArray_encode_float(PackedByteArray *p_instance, int64_t p_offset, double p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 4);
uint8_t *w = p_instance->ptrw();
encode_float(p_value, &w[p_offset]);
}
static void func_PackedByteArray_encode_double(PackedByteArray *p_instance, int64_t p_offset, double p_value) {
uint64_t size = p_instance->size();
ERR_FAIL_COND(p_offset < 0 || p_offset > int64_t(size) - 8);
uint8_t *w = p_instance->ptrw();
encode_double(p_value, &w[p_offset]);
}
static int64_t func_PackedByteArray_encode_var(PackedByteArray *p_instance, int64_t p_offset, const Variant &p_value, bool p_allow_objects) {
uint64_t size = p_instance->size();
ERR_FAIL_COND_V(p_offset < 0, -1);
uint8_t *w = p_instance->ptrw();
int len;
Error err = encode_variant(p_value, nullptr, len, p_allow_objects);
if (err != OK) {
return -1;
}
if (uint64_t(p_offset + len) > size) {
return -1; // did not fit
}
encode_variant(p_value, w + p_offset, len, p_allow_objects);
return len;
}
Fix `PackedStringArray.to_byte_array()` to return UTF-8 encoded data instead of pointers.
2025-02-07 10:19:19 +02:00
static PackedByteArray func_PackedStringArray_to_byte_array(PackedStringArray *p_instance) {
PackedByteArray ret;
uint64_t size = p_instance->size();
const String *r = p_instance->ptr();
for (uint64_t i = 0; i < size; i++) {
ret.append_array(r[i].to_utf8_buffer());
ret.append(0);
}
return ret;
}
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 15:59:37 -03:00
static void func_Callable_call(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
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
callable->callp(p_args, p_argcount, r_ret, r_error);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
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 15:59:37 -03:00
static void func_Callable_call_deferred(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
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
callable->call_deferredp(p_args, p_argcount);
Huge Amount of BugFix -=-=-=-=-=-=-=-=-=-=- -Fixes to Collada Exporter (avoid crash situtions) -Fixed to Collada Importer (Fixed Animation Optimizer Bugs) -Fixes to RigidBody/RigidBody2D body_enter/body_exit, was buggy -Fixed ability for RigidBody/RigidBody2D to get contacts reported and bodyin/out in Kinematic mode. -Added proper trigger support for 3D Physics shapes -Changed proper value for Z-Offset in OmniLight -Fixed spot attenuation bug in SpotLight -Fixed some 3D and 2D spatial soudn bugs related to distance attenuation. -Fixed bugs in EventPlayer (channels were muted by default) -Fix in ButtonGroup (get nodes in group are now returned in order) -Fixed Linear->SRGB Conversion, previous algo sucked, new algo works OK -Changed SRGB->Linear conversion to use hardware if supported, improves texture quality a lot -Fixed options for Y-Fov and X-Fov in camera, should be more intuitive. -Fixed bugs related to viewports and transparency Huge Amount of New Stuff: -=-=-=-=-=-=-=-==-=-=-=- -Ability to manually advance an AnimationPlayer that is inactive (with advance() function) -More work in WinRT platform -Added XY normalmap support, imports on this format by default. Reduces normlmap size and enables much nice compression using LATC -Added Anisotropic filter support to textures, can be specified on import -Added support for Non-Square, Isometric and Hexagonal tilemaps in TileMap. -Added Isometric Dungeon demo. -Added simple hexagonal map demo. -Added Truck-Town demo. Shows how most types of joints and vehicles are used. Please somebody make a nicer town, this one is too hardcore. -Added an Object-Picking API to both RigidBody and Area! (and relevant demo)
2014-10-03 00:10:51 -03:00
}
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
static void func_Callable_rpc(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
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
callable->rpcp(0, p_args, p_argcount, r_error);
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
}
static void func_Callable_rpc_id(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
if (p_argcount == 0) {
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.expected = 1;
} else if (p_args[0]->get_type() != Variant::INT) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_ARGUMENT;
r_error.argument = 0;
r_error.expected = Variant::INT;
} else {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
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
callable->rpcp(*p_args[0], &p_args[1], p_argcount - 1, r_error);
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
}
}
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 15:59:37 -03:00
static void func_Callable_bind(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Callable *callable = VariantGetInternalPtr<Callable>::get_ptr(v);
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
r_ret = callable->bindp(p_args, p_argcount);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Add methods to get argument count of methods Added to: * `Callable`s * `Object`s * `ClassDB` * `Script(Instance)`s
2024-01-28 15:16:09 +01:00
static int func_Callable_get_argument_count(Callable *p_callable) {
return p_callable->get_argument_count();
}
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 15:59:37 -03:00
static void func_Signal_emit(Variant *v, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Signal *signal = VariantGetInternalPtr<Signal>::get_ptr(v);
signal->emit(p_args, p_argcount);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
struct ConstantData {
Make enum/constant binds 64-bit.
2022-05-09 12:47:10 +03:00
HashMap<StringName, int64_t> value;
Make sure builtin types' constants remain in order This adds a list of constants for VariantCall to make sure the order of register is kept when showing in the editor help and in the documentation. This also remove the sorting of constants from the doctool, so it keeps the natural order in classes.xml.
2016-07-05 16:57:17 -03:00
#ifdef DEBUG_ENABLED
List<StringName> value_ordered;
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, Variant> variant_value;
Docs: Fix order of variant constants.
2020-05-20 16:45:42 +03:00
#ifdef DEBUG_ENABLED
List<StringName> variant_value_ordered;
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
};
static ConstantData *constant_data;
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
static void add_constant(int p_type, const StringName &p_constant_name, int64_t p_constant_value) {
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(constant_data[p_type].value.has(p_constant_name));
ERR_FAIL_COND(enum_data[p_type].value.has(p_constant_name));
ERR_FAIL_COND(enum_data[p_type].value_to_enum.has(p_constant_name));
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Make sure builtin types' constants remain in order This adds a list of constants for VariantCall to make sure the order of register is kept when showing in the editor help and in the documentation. This also remove the sorting of constants from the doctool, so it keeps the natural order in classes.xml.
2016-07-05 16:57:17 -03:00
constant_data[p_type].value[p_constant_name] = p_constant_value;
#ifdef DEBUG_ENABLED
constant_data[p_type].value_ordered.push_back(p_constant_name);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Make sure builtin types' constants remain in order This adds a list of constants for VariantCall to make sure the order of register is kept when showing in the editor help and in the documentation. This also remove the sorting of constants from the doctool, so it keeps the natural order in classes.xml.
2016-07-05 16:57:17 -03:00
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
static void add_variant_constant(int p_type, const StringName &p_constant_name, const Variant &p_constant_value) {
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
constant_data[p_type].variant_value[p_constant_name] = p_constant_value;
Docs: Fix order of variant constants.
2020-05-20 16:45:42 +03:00
#ifdef DEBUG_ENABLED
constant_data[p_type].variant_value_ordered.push_back(p_constant_name);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
}
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
struct EnumData {
HashMap<StringName, HashMap<StringName, int>> value;
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
HashMap<StringName, StringName> value_to_enum;
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
};
static EnumData *enum_data;
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
static void add_enum_constant(int p_type, const StringName &p_enum_type_name, const StringName &p_enumeration_name, int p_enum_value) {
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
#ifdef DEBUG_ENABLED
ERR_FAIL_COND(constant_data[p_type].value.has(p_enumeration_name));
ERR_FAIL_COND(enum_data[p_type].value.has(p_enumeration_name));
ERR_FAIL_COND(enum_data[p_type].value_to_enum.has(p_enumeration_name));
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
enum_data[p_type].value[p_enum_type_name][p_enumeration_name] = p_enum_value;
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
enum_data[p_type].value_to_enum[p_enumeration_name] = p_enum_type_name;
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
};
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
_VariantCall::ConstantData *_VariantCall::constant_data = nullptr;
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
_VariantCall::EnumData *_VariantCall::enum_data = nullptr;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
struct VariantBuiltInMethodInfo {
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
void (*call)(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, const Vector<Variant> &p_defvals, Callable::CallError &r_error) = nullptr;
Variant::ValidatedBuiltInMethod validated_call = nullptr;
Variant::PTRBuiltInMethod ptrcall = nullptr;
Property reporty base type when a function fails, fixes #4581 probably also closes other issues
2016-06-20 01:15:02 -03: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 13:16:08 -03:00
Vector<Variant> default_arguments;
Vector<String> argument_names;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
bool is_const = false;
bool is_static = false;
bool has_return_type = false;
bool is_vararg = false;
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 13:16:08 -03:00
Variant::Type return_type;
Style: Partially apply clang-tidy's `cppcoreguidelines-pro-type-member-init` Didn't commit all the changes where it wants to initialize a struct with `{}`. Should be reviewed in a separate PR. Option `IgnoreArrays` enabled for now to be conservative, can be disabled to see if it proposes more useful changes. Also fixed manually a handful of other missing initializations / moved some from constructors.
2022-05-02 16:28:25 +02:00
int argument_count = 0;
Variant::Type (*get_argument_type)(int p_arg) = nullptr;
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
MethodInfo get_method_info(const StringName &p_name) const {
MethodInfo mi;
mi.name = p_name;
if (has_return_type) {
mi.return_val.type = return_type;
if (mi.return_val.type == Variant::NIL) {
mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
}
}
if (is_const) {
mi.flags |= METHOD_FLAG_CONST;
}
if (is_vararg) {
mi.flags |= METHOD_FLAG_VARARG;
}
if (is_static) {
mi.flags |= METHOD_FLAG_STATIC;
}
for (int i = 0; i < argument_count; i++) {
PropertyInfo pi;
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
pi.name = argument_names[i];
#else
pi.name = "arg" + itos(i + 1);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
pi.type = (*get_argument_type)(i);
if (pi.type == Variant::NIL) {
pi.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
}
mi.arguments.push_back(pi);
}
mi.default_arguments = default_arguments;
return mi;
}
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 13:16:08 -03:00
};
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
typedef AHashMap<StringName, VariantBuiltInMethodInfo> BuiltinMethodMap;
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 13:16:08 -03:00
static BuiltinMethodMap *builtin_method_info;
static List<StringName> *builtin_method_names;
template <typename T>
static void register_builtin_method(const Vector<String> &p_argnames, const Vector<Variant> &p_def_args) {
StringName name = T::get_name();
ERR_FAIL_COND(builtin_method_info[T::get_base_type()].has(name));
VariantBuiltInMethodInfo imi;
imi.call = T::call;
imi.validated_call = T::validated_call;
Set builtin varrarg ptrcalls, called without arg.
2023-04-14 15:42:03 +08:00
imi.ptrcall = T::ptrcall;
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 13:16:08 -03:00
imi.default_arguments = p_def_args;
imi.argument_names = p_argnames;
imi.is_const = T::is_const();
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 10:56:34 -03:00
imi.is_static = T::is_static();
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 13:16:08 -03:00
imi.is_vararg = T::is_vararg();
imi.has_return_type = T::has_return_type();
imi.return_type = T::get_return_type();
imi.argument_count = T::get_argument_count();
imi.get_argument_type = T::get_argument_type;
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 13:16:08 -03:00
ERR_FAIL_COND(!imi.is_vararg && imi.argument_count != imi.argument_names.size());
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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 13:16:08 -03:00
builtin_method_info[T::get_base_type()].insert(name, imi);
builtin_method_names[T::get_base_type()].push_back(name);
}
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::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
if (type == Variant::OBJECT) {
//call object
Object *obj = _get_obj().obj;
if (!obj) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 16:27:19 -03:00
r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
Property reporty base type when a function fails, fixes #4581 probably also closes other issues
2016-06-20 01:15:02 -03:00
return;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
#ifdef DEBUG_ENABLED
Rename Reference to RefCounted
2021-06-04 18:03:15 +02:00
if (EngineDebugger::is_active() && !_get_obj().id.is_ref_counted() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 16:27:19 -03:00
r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 16:03:10 -03:00
return;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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
r_ret = _get_obj().obj->callp(p_method, p_args, p_argcount, r_error);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:10:04 -07:00
} else {
r_error.error = Callable::CallError::CALL_OK;
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].getptr(p_method);
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 13:10:04 -07:00
if (!imf) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
return;
}
imf->call(this, p_args, p_argcount, r_ret, imf->default_arguments, r_error);
}
}
void Variant::call_const(const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
if (type == Variant::OBJECT) {
//call object
Object *obj = _get_obj().obj;
if (!obj) {
r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return;
}
#ifdef DEBUG_ENABLED
if (EngineDebugger::is_active() && !_get_obj().id.is_ref_counted() && ObjectDB::get_instance(_get_obj().id) == nullptr) {
r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return;
}
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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 13:10:04 -07:00
r_ret = _get_obj().obj->call_const(p_method, p_args, p_argcount, r_error);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
//else if (type==Variant::METHOD) {
} else {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 16:27:19 -03:00
r_error.error = Callable::CallError::CALL_OK;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *imf = builtin_method_info[type].getptr(p_method);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 16:27:19 -03: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 13:16:08 -03:00
if (!imf) {
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 15:59:37 -03:00
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
return;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:10:04 -07:00
if (!imf->is_const) {
r_error.error = Callable::CallError::CALL_ERROR_METHOD_NOT_CONST;
return;
}
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 13:16:08 -03:00
imf->call(this, p_args, p_argcount, r_ret, imf->default_arguments, r_error);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
void Variant::call_static(Variant::Type p_type, const StringName &p_method, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
r_error.error = Callable::CallError::CALL_OK;
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *imf = builtin_method_info[p_type].getptr(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 10:56:34 -03:00
if (!imf) {
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
return;
}
if (!imf->is_static) {
r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
return;
}
imf->call(nullptr, p_args, p_argcount, r_ret, imf->default_arguments, r_error);
}
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-19 21:01:41 -03:00
bool Variant::has_method(const StringName &p_method) const {
if (type == OBJECT) {
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 16:03:10 -03:00
Object *obj = get_validated_object();
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (!obj) {
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-19 21:01:41 -03:00
return false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Changed logic and optimized ObjectID in ObjectDB and Variant, removed RefPtr.
2020-02-13 16:03:10 -03:00
return obj->has_method(p_method);
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-19 21:01:41 -03: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 13:16:08 -03:00
return builtin_method_info[type].has(p_method);
- more fixes on #672 on windows - added #660, but need help on osx, help please I don't have a mac! - fixed #667 and #668 (eol detection in comments) - added #670 (hint when using method without () )
2014-09-19 21:01:41 -03: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 13:16:08 -03:00
bool Variant::has_builtin_method(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
return builtin_method_info[p_type].has(p_method);
}
More progress on visual script editing
2016-08-03 11:28:20 -03: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 13:16:08 -03:00
Variant::ValidatedBuiltInMethod Variant::get_validated_builtin_method(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, nullptr);
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 13:16:08 -03:00
return method->validated_call;
}
More progress on visual script editing
2016-08-03 11:28:20 -03: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 13:16:08 -03:00
Variant::PTRBuiltInMethod Variant::get_ptr_builtin_method(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, nullptr);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, nullptr);
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 13:16:08 -03:00
return method->ptrcall;
More progress on visual script editing
2016-08-03 11:28:20 -03:00
}
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
MethodInfo Variant::get_builtin_method_info(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, MethodInfo());
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
ERR_FAIL_NULL_V(method, MethodInfo());
return method->get_method_info(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 13:16:08 -03:00
int Variant::get_builtin_method_argument_count(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, 0);
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 13:16:08 -03:00
return method->argument_count;
Fixed constness of variant functions, as well as visual script sequence ports. Closes #11258
2017-09-25 17:08:48 -03: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 13:16:08 -03:00
Variant::Type Variant::get_builtin_method_argument_type(Variant::Type p_type, const StringName &p_method, int p_argument) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::NIL);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, Variant::NIL);
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 13:16:08 -03:00
ERR_FAIL_INDEX_V(p_argument, method->argument_count, Variant::NIL);
return method->get_argument_type(p_argument);
}
More progress on visual script editing
2016-08-03 11:28:20 -03: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 13:16:08 -03:00
String Variant::get_builtin_method_argument_name(Variant::Type p_type, const StringName &p_method, int p_argument) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, String());
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, String());
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 13:16:08 -03:00
ERR_FAIL_INDEX_V(p_argument, method->argument_count, String());
return method->argument_names[p_argument];
#else
return "arg" + itos(p_argument + 1);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
More progress on visual script editing
2016-08-03 11:28:20 -03: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 13:16:08 -03:00
Vector<Variant> Variant::get_builtin_method_default_arguments(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Vector<Variant>());
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, Vector<Variant>());
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 13:16:08 -03:00
return method->default_arguments;
More progress on visual script editing
2016-08-03 11:28:20 -03: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 13:16:08 -03:00
bool Variant::has_builtin_method_return_value(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, false);
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 13:16:08 -03:00
return method->has_return_type;
}
void Variant::get_builtin_method_list(Variant::Type p_type, List<StringName> *p_list) {
ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
Use const references where possible for List range iterators
2021-07-24 15:46:25 +02:00
for (const StringName &E : builtin_method_names[p_type]) {
Use C++ iterators for Lists in many situations
2021-07-15 23:45:57 -04:00
p_list->push_back(E);
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +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 13:16:08 -03:00
}
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 11:09:06 -03:00
int Variant::get_builtin_method_count(Variant::Type p_type) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, -1);
return builtin_method_names[p_type].size();
}
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 13:16:08 -03:00
Variant::Type Variant::get_builtin_method_return_type(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, Variant::NIL);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, Variant::NIL);
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 13:16:08 -03:00
return method->return_type;
}
bool Variant::is_builtin_method_const(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, false);
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 13:16:08 -03:00
return method->is_const;
}
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 10:56:34 -03:00
bool Variant::is_builtin_method_static(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, false);
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 10:56:34 -03:00
return method->is_static;
}
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 13:16:08 -03:00
bool Variant::is_builtin_method_vararg(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, false);
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 13:16:08 -03:00
return method->is_vararg;
More progress on visual script editing
2016-08-03 11:28:20 -03:00
}
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 12:58:49 -03:00
uint32_t Variant::get_builtin_method_hash(Variant::Type p_type, const StringName &p_method) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[p_type].getptr(p_method);
[Core] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 16:11:33 +02:00
ERR_FAIL_NULL_V(method, 0);
Clean up Hash Functions Clean up and do fixes to hash functions and newly introduced murmur3 hashes in #61934 * Clean up usage of murmur3 * Fixed usages of binary murmur3 on floats (this is invalid) * Changed DJB2 to use xor (which seems to be better)
2022-06-18 16:20:55 +02:00
uint32_t hash = hash_murmur3_one_32(method->is_const);
hash = hash_murmur3_one_32(method->is_static, hash);
hash = hash_murmur3_one_32(method->is_vararg, hash);
hash = hash_murmur3_one_32(method->has_return_type, hash);
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 12:58:49 -03:00
if (method->has_return_type) {
Clean up Hash Functions Clean up and do fixes to hash functions and newly introduced murmur3 hashes in #61934 * Clean up usage of murmur3 * Fixed usages of binary murmur3 on floats (this is invalid) * Changed DJB2 to use xor (which seems to be better)
2022-06-18 16:20:55 +02:00
hash = hash_murmur3_one_32(method->return_type, hash);
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 12:58:49 -03:00
}
Clean up Hash Functions Clean up and do fixes to hash functions and newly introduced murmur3 hashes in #61934 * Clean up usage of murmur3 * Fixed usages of binary murmur3 on floats (this is invalid) * Changed DJB2 to use xor (which seems to be better)
2022-06-18 16:20:55 +02:00
hash = hash_murmur3_one_32(method->argument_count, hash);
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 12:58:49 -03:00
for (int i = 0; i < method->argument_count; i++) {
Clean up Hash Functions Clean up and do fixes to hash functions and newly introduced murmur3 hashes in #61934 * Clean up usage of murmur3 * Fixed usages of binary murmur3 on floats (this is invalid) * Changed DJB2 to use xor (which seems to be better)
2022-06-18 16:20:55 +02:00
hash = hash_murmur3_one_32(method->get_argument_type(i), hash);
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 12:58:49 -03:00
}
Clean up Hash Functions Clean up and do fixes to hash functions and newly introduced murmur3 hashes in #61934 * Clean up usage of murmur3 * Fixed usages of binary murmur3 on floats (this is invalid) * Changed DJB2 to use xor (which seems to be better)
2022-06-18 16:20:55 +02:00
return hash_fmix32(hash);
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 12:58:49 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
void Variant::get_method_list(List<MethodInfo> *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 13:16:08 -03:00
if (type == OBJECT) {
Object *obj = get_validated_object();
if (obj) {
obj->get_method_list(p_list);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
} else {
Use const references where possible for List range iterators
2021-07-24 15:46:25 +02:00
for (const StringName &E : builtin_method_names[type]) {
Remove `OAHashMap`, in favour of `AHashMap`. The two types had (mostly) the same decisions, but `AHashMap` is a faster implementation, and is more consistent with `HashMap`.
2025-05-31 15:50:10 +02:00
const VariantBuiltInMethodInfo *method = builtin_method_info[type].getptr(E);
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 13:16:08 -03:00
ERR_CONTINUE(!method);
Core: Allow methods of built-in `Variant` types to be used as Callables
2023-09-24 23:33:28 +03:00
p_list->push_back(method->get_method_info(E));
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 13:16:08 -03:00
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 16:27:19 -03:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
void Variant::get_constants_for_type(Variant::Type p_type, List<StringName> *p_constants) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
Fix more issues found by cppcheck.
2022-04-07 13:23:40 +03:00
const _VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Make sure builtin types' constants remain in order This adds a list of constants for VariantCall to make sure the order of register is kept when showing in the editor help and in the documentation. This also remove the sorting of constants from the doctool, so it keeps the natural order in classes.xml.
2016-07-05 16:57:17 -03:00
#ifdef DEBUG_ENABLED
Fix more issues found by cppcheck.
2022-04-07 13:23:40 +03:00
for (const List<StringName>::Element *E = cd.value_ordered.front(); E; E = E->next()) {
Make sure builtin types' constants remain in order This adds a list of constants for VariantCall to make sure the order of register is kept when showing in the editor help and in the documentation. This also remove the sorting of constants from the doctool, so it keeps the natural order in classes.xml.
2016-07-05 16:57:17 -03:00
p_constants->push_back(E->get());
#else
Make enum/constant binds 64-bit.
2022-05-09 12:47:10 +03:00
for (const KeyValue<StringName, int64_t> &E : cd.value) {
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
p_constants->push_back(E.key);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Docs: Fix order of variant constants.
2020-05-20 16:45:42 +03:00
#ifdef DEBUG_ENABLED
Fix more issues found by cppcheck.
2022-04-07 13:23:40 +03:00
for (const List<StringName>::Element *E = cd.variant_value_ordered.front(); E; E = E->next()) {
Docs: Fix order of variant constants.
2020-05-20 16:45:42 +03:00
p_constants->push_back(E->get());
#else
Use range iterators for `Map`
2021-08-09 14:13:42 -06:00
for (const KeyValue<StringName, Variant> &E : cd.variant_value) {
p_constants->push_back(E.key);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
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 11:09:06 -03:00
int Variant::get_constants_count_for_type(Variant::Type p_type) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, -1);
_VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
return cd.value.size() + cd.variant_value.size();
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
bool Variant::has_constant(Variant::Type p_type, const StringName &p_value) {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
_VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
return cd.value.has(p_value) || cd.variant_value.has(p_value);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Variant Variant::get_constant_value(Variant::Type p_type, const StringName &p_value, bool *r_valid) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (r_valid) {
Basic type constants for visual script
2016-09-02 02:13:12 -03:00
*r_valid = false;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
_VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
Make enum/constant binds 64-bit.
2022-05-09 12:47:10 +03:00
HashMap<StringName, int64_t>::Iterator E = cd.value.find(p_value);
Basic type constants for visual script
2016-09-02 02:13:12 -03:00
if (!E) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
HashMap<StringName, Variant>::Iterator F = cd.variant_value.find(p_value);
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
if (F) {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (r_valid) {
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
*r_valid = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
return F->value;
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
} else {
return -1;
}
Basic type constants for visual script
2016-09-02 02:13:12 -03:00
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (r_valid) {
Basic type constants for visual script
2016-09-02 02:13:12 -03:00
*r_valid = true;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Basic type constants for visual script
2016-09-02 02:13:12 -03:00
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
return E->value;
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
void Variant::get_enums_for_type(Variant::Type p_type, List<StringName> *p_enums) {
ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
for (const KeyValue<StringName, HashMap<StringName, int>> &E : enum_data.value) {
p_enums->push_back(E.key);
}
}
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
void Variant::get_enumerations_for_enum(Variant::Type p_type, const StringName &p_enum_name, List<StringName> *p_enumerations) {
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
for (const KeyValue<StringName, HashMap<StringName, int>> &E : enum_data.value) {
for (const KeyValue<StringName, int> &V : E.value) {
p_enumerations->push_back(V.key);
}
}
}
Add const lvalue ref to container parameters
2021-08-01 16:47:20 -03:00
int Variant::get_enum_value(Variant::Type p_type, const StringName &p_enum_name, const StringName &p_enumeration, bool *r_valid) {
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
if (r_valid) {
*r_valid = false;
}
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, -1);
_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
HashMap<StringName, HashMap<StringName, int>>::Iterator E = enum_data.value.find(p_enum_name);
if (!E) {
return -1;
}
HashMap<StringName, int>::Iterator V = E->value.find(p_enumeration);
if (!V) {
return -1;
}
if (r_valid) {
*r_valid = true;
}
return V->value;
}
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
bool Variant::has_enum(Variant::Type p_type, const StringName &p_enum_name) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, false);
_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
return enum_data.value.has(p_enum_name);
}
StringName Variant::get_enum_for_enumeration(Variant::Type p_type, const StringName &p_enumeration) {
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, StringName());
_VariantCall::EnumData &enum_data = _VariantCall::enum_data[p_type];
const StringName *enum_name = enum_data.value_to_enum.getptr(p_enumeration);
return (enum_name == nullptr) ? StringName() : *enum_name;
}
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 13:16:08 -03:00
#define bind_method(m_type, m_method, m_arg_names, m_default_args) \
METHOD_CLASS(m_type, m_method, &m_type::m_method); \
register_builtin_method<Method_##m_type##_##m_method>(m_arg_names, m_default_args);
#else
#define bind_method(m_type, m_method, m_arg_names, m_default_args) \
METHOD_CLASS(m_type, m_method, &m_type ::m_method); \
register_builtin_method<Method_##m_type##_##m_method>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
Unify String and StringName
2022-12-05 21:46:47 -05:00
#define bind_convert_method(m_type_from, m_type_to, m_method, m_arg_names, m_default_args) \
CONVERT_METHOD_CLASS(m_type_from, m_method, &m_type_to::m_method); \
register_builtin_method<Method_##m_type_from##_##m_method>(m_arg_names, m_default_args);
#else
#define bind_convert_method(m_type_from, m_type_to, m_method, m_arg_names, m_default_args) \
CONVERT_METHOD_CLASS(m_type_from, m_method, &m_type_to ::m_method); \
register_builtin_method<Method_##m_type_from##_##m_method>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Unify String and StringName
2022-12-05 21:46:47 -05:00
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 10:56:34 -03:00
#define bind_static_method(m_type, m_method, m_arg_names, m_default_args) \
STATIC_METHOD_CLASS(m_type, m_method, m_type::m_method); \
register_builtin_method<Method_##m_type##_##m_method>(m_arg_names, m_default_args);
#else
#define bind_static_method(m_type, m_method, m_arg_names, m_default_args) \
STATIC_METHOD_CLASS(m_type, m_method, m_type ::m_method); \
register_builtin_method<Method_##m_type##_##m_method>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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 10:56:34 -03:00
Use Grisu2 algorithm in String::num_scientific to fix serializing
2024-11-01 02:02:09 -07:00
#ifdef DEBUG_ENABLED
#define bind_static_methodv(m_type, m_name, m_method, m_arg_names, m_default_args) \
STATIC_METHOD_CLASS(m_type, m_name, m_method); \
register_builtin_method<Method_##m_type##_##m_name>(m_arg_names, m_default_args);
#else
#define bind_static_methodv(m_type, m_name, m_method, m_arg_names, m_default_args) \
STATIC_METHOD_CLASS(m_type, m_name, m_method); \
register_builtin_method<Method_##m_type##_##m_name>(sarray(), m_default_args);
#endif
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 13:16:08 -03:00
#define bind_methodv(m_type, m_name, m_method, m_arg_names, m_default_args) \
METHOD_CLASS(m_type, m_name, m_method); \
register_builtin_method<Method_##m_type##_##m_name>(m_arg_names, m_default_args);
#else
#define bind_methodv(m_type, m_name, m_method, m_arg_names, m_default_args) \
METHOD_CLASS(m_type, m_name, m_method); \
register_builtin_method<Method_##m_type##_##m_name>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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 15:59:37 -03:00
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
Unify String and StringName
2022-12-05 21:46:47 -05:00
#define bind_convert_methodv(m_type_from, m_type_to, m_name, m_method, m_arg_names, m_default_args) \
CONVERT_METHOD_CLASS(m_type_from, m_name, m_method); \
register_builtin_method<Method_##m_type_from##_##m_name>(m_arg_names, m_default_args);
#else
#define bind_convert_methodv(m_type_from, m_type_to, m_name, m_method, m_arg_names, m_default_args) \
CONVERT_METHOD_CLASS(m_type_from, m_name, m_method); \
register_builtin_method<Method_##m_type_from##_##m_name>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Unify String and StringName
2022-12-05 21:46:47 -05:00
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
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 13:16:08 -03:00
#define bind_function(m_type, m_name, m_method, m_arg_names, m_default_args) \
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
FUNCTION_CLASS(m_type, m_name, m_method, true); \
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 13:16:08 -03:00
register_builtin_method<Method_##m_type##_##m_name>(m_arg_names, m_default_args);
#else
#define bind_function(m_type, m_name, m_method, m_arg_names, m_default_args) \
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
FUNCTION_CLASS(m_type, m_name, m_method, true); \
register_builtin_method<Method_##m_type##_##m_name>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#ifdef DEBUG_ENABLED
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
#define bind_functionnc(m_type, m_name, m_method, m_arg_names, m_default_args) \
FUNCTION_CLASS(m_type, m_name, m_method, false); \
register_builtin_method<Method_##m_type##_##m_name>(m_arg_names, m_default_args);
#else
#define bind_functionnc(m_type, m_name, m_method, m_arg_names, m_default_args) \
FUNCTION_CLASS(m_type, m_name, m_method, false); \
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 13:16:08 -03:00
register_builtin_method<Method_##m_type##_##m_name>(sarray(), m_default_args);
Style: Remove redundant `DEBUG_METHODS_ENABLED` • Replaced with functionally identical and far more ubiquitous `DEBUG_ENABLED`
2025-05-15 13:09:41 -05:00
#endif // DEBUG_ENABLED
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 13:16:08 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
#define bind_string_method(m_method, m_arg_names, m_default_args) \
bind_method(String, m_method, m_arg_names, m_default_args); \
bind_convert_method(StringName, String, m_method, m_arg_names, m_default_args);
#define bind_string_methodv(m_name, m_method, m_arg_names, m_default_args) \
bind_methodv(String, m_name, m_method, m_arg_names, m_default_args); \
bind_convert_methodv(StringName, String, m_name, m_method, m_arg_names, m_default_args);
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 13:16:08 -03:00
#define bind_custom(m_type, m_name, m_method, m_has_return, m_ret_type) \
VARARG_CLASS(m_type, m_name, m_method, m_has_return, m_ret_type) \
register_builtin_method<Method_##m_type##_##m_name>(sarray(), Vector<Variant>());
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
#define bind_custom1(m_type, m_name, m_method, m_arg_type, m_arg_name) \
VARARG_CLASS1(m_type, m_name, m_method, m_arg_type) \
register_builtin_method<Method_##m_type##_##m_name>(sarray(m_arg_name), Vector<Variant>());
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
static void _register_variant_builtin_methods_string() {
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
_VariantCall::constant_data = memnew_arr(_VariantCall::ConstantData, Variant::VARIANT_MAX);
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
_VariantCall::enum_data = memnew_arr(_VariantCall::EnumData, Variant::VARIANT_MAX);
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 13:16:08 -03:00
builtin_method_info = memnew_arr(BuiltinMethodMap, Variant::VARIANT_MAX);
builtin_method_names = memnew_arr(List<StringName>, Variant::VARIANT_MAX);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
/* String */
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 15:59:37 -03:00
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(casecmp_to, sarray("to"), varray());
bind_string_method(nocasecmp_to, sarray("to"), varray());
Add `naturalcasecmp_to` function to `String` Functions as a complement to `naturalnocasecmp_to`
2023-05-04 20:32:45 +02:00
bind_string_method(naturalcasecmp_to, sarray("to"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(naturalnocasecmp_to, sarray("to"), varray());
Fix sorting of files/dirs in dialogs Sorts leading `_` before other characters except `.`.
2024-02-02 16:50:23 +01:00
bind_string_method(filecasecmp_to, sarray("to"), varray());
bind_string_method(filenocasecmp_to, sarray("to"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(length, sarray(), varray());
bind_string_method(substr, sarray("from", "len"), varray(-1));
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(get_slice, static_cast<String (String::*)(const String &, int) const>(&String::get_slice), sarray("delimiter", "slice"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(get_slicec, sarray("delimiter", "slice"), varray());
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(get_slice_count, static_cast<int (String::*)(const String &) const>(&String::get_slice_count), sarray("delimiter"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_methodv(find, static_cast<int (String::*)(const String &, int) const>(&String::find), sarray("what", "from"), varray(0));
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(findn, static_cast<int (String::*)(const String &, int) const>(&String::findn), sarray("what", "from"), varray(0));
bind_string_methodv(count, static_cast<int (String::*)(const String &, int, int) const>(&String::count), sarray("what", "from", "to"), varray(0, 0));
bind_string_methodv(countn, static_cast<int (String::*)(const String &, int, int) const>(&String::countn), sarray("what", "from", "to"), varray(0, 0));
bind_string_methodv(rfind, static_cast<int (String::*)(const String &, int) const>(&String::rfind), sarray("what", "from"), varray(-1));
bind_string_methodv(rfindn, static_cast<int (String::*)(const String &, int) const>(&String::rfindn), sarray("what", "from"), varray(-1));
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(match, sarray("expr"), varray());
bind_string_method(matchn, sarray("expr"), varray());
bind_string_methodv(begins_with, static_cast<bool (String::*)(const String &) const>(&String::begins_with), sarray("text"), varray());
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(ends_with, static_cast<bool (String::*)(const String &) const>(&String::ends_with), sarray("text"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(is_subsequence_of, sarray("text"), varray());
bind_string_method(is_subsequence_ofn, sarray("text"), varray());
bind_string_method(bigrams, sarray(), varray());
bind_string_method(similarity, sarray("text"), varray());
bind_string_method(format, sarray("values", "placeholder"), varray("{_}"));
bind_string_methodv(replace, static_cast<String (String::*)(const String &, const String &) const>(&String::replace), sarray("what", "forwhat"), varray());
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(replacen, static_cast<String (String::*)(const String &, const String &) const>(&String::replacen), sarray("what", "forwhat"), varray());
Add `String::replace_char(s)` methods for performance and convenience
2024-05-28 12:15:00 +02:00
bind_string_method(replace_char, sarray("key", "with"), varray());
bind_string_methodv(replace_chars, static_cast<String (String::*)(const String &, char32_t) const>(&String::replace_chars), sarray("keys", "with"), varray());
Add `String::remove_char(s)` methods for performance and convenience
2024-05-28 12:55:07 +02:00
bind_string_method(remove_char, sarray("what"), varray());
bind_string_methodv(remove_chars, static_cast<String (String::*)(const String &) const>(&String::remove_chars), sarray("chars"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(repeat, sarray("count"), varray());
Add `String.reverse` method
2023-06-21 20:40:48 +03:00
bind_string_method(reverse, sarray(), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(insert, sarray("position", "what"), varray());
Reimplement String.erase
2023-03-30 15:45:45 +02:00
bind_string_method(erase, sarray("position", "chars"), varray(1));
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(capitalize, sarray(), varray());
bind_string_method(to_camel_case, sarray(), varray());
bind_string_method(to_pascal_case, sarray(), varray());
bind_string_method(to_snake_case, sarray(), varray());
Add Options, Functions and Settings to convert Node-Names and Strings to kebab-case - refactored and renamed String::_camelcase_to_underscore to String:_separate_compound_words - refactored String::to_snake_case to work with the refactored String::_separate_compound_words - created char_utils::is_hyphen to catch all hyphen variants in kebab-case conversion - created String::to_kebab_case using the new String::_separate_compound_words - created corresponding Documentation in String and StringName - simplified both switch statements in EditorNode and ProjectDialog - added new kebab-casing Option for Node Names in ProjectSettings - added missing camelCase Options to Scene- and Node-Names in ProjectSettings - simplified Mono RuntimeInterop Functions - hooked up the ConnectionsDialog - created additional Unit Tests
2024-07-28 21:32:28 +02:00
bind_string_method(to_kebab_case, sarray(), varray());
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(split, static_cast<Vector<String> (String::*)(const String &, bool, int) const>(&String::split), sarray("delimiter", "allow_empty", "maxsplit"), varray("", true, 0));
bind_string_methodv(rsplit, static_cast<Vector<String> (String::*)(const String &, bool, int) const>(&String::rsplit), sarray("delimiter", "allow_empty", "maxsplit"), varray("", true, 0));
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(split_floats, sarray("delimiter", "allow_empty"), varray(true));
bind_string_method(join, sarray("parts"), varray());
bind_string_method(to_upper, sarray(), varray());
bind_string_method(to_lower, sarray(), varray());
bind_string_method(left, sarray("length"), varray());
bind_string_method(right, sarray("length"), varray());
bind_string_method(strip_edges, sarray("left", "right"), varray(true, true));
bind_string_method(strip_escapes, sarray(), varray());
bind_string_method(lstrip, sarray("chars"), varray());
bind_string_method(rstrip, sarray("chars"), varray());
bind_string_method(get_extension, sarray(), varray());
bind_string_method(get_basename, sarray(), varray());
Rename "file" param for str.path_join() to "path"
2025-02-24 23:52:33 +01:00
bind_string_method(path_join, sarray("path"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(unicode_at, sarray("at"), varray());
bind_string_method(indent, sarray("prefix"), varray());
bind_string_method(dedent, sarray(), varray());
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 15:59:37 -03:00
bind_method(String, hash, sarray(), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(md5_text, sarray(), varray());
bind_string_method(sha1_text, sarray(), varray());
bind_string_method(sha256_text, sarray(), varray());
bind_string_method(md5_buffer, sarray(), varray());
bind_string_method(sha1_buffer, sarray(), varray());
bind_string_method(sha256_buffer, sarray(), varray());
bind_string_method(is_empty, sarray(), varray());
bind_string_methodv(contains, static_cast<bool (String::*)(const String &) const>(&String::contains), sarray("what"), varray());
[Core] Add case-insensitive `String::containsn`
2024-05-06 10:26:10 +02:00
bind_string_methodv(containsn, static_cast<bool (String::*)(const String &) const>(&String::containsn), sarray("what"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(is_absolute_path, sarray(), varray());
bind_string_method(is_relative_path, sarray(), varray());
bind_string_method(simplify_path, sarray(), varray());
bind_string_method(get_base_dir, sarray(), varray());
bind_string_method(get_file, sarray(), varray());
bind_string_method(xml_escape, sarray("escape_quotes"), varray(false));
bind_string_method(xml_unescape, sarray(), varray());
bind_string_method(uri_encode, sarray(), varray());
bind_string_method(uri_decode, sarray(), varray());
Add `uri_file_decode` to handle `+` in file names.
2025-04-07 22:49:57 +03:00
bind_string_method(uri_file_decode, sarray(), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(c_escape, sarray(), varray());
bind_string_method(c_unescape, sarray(), varray());
bind_string_method(json_escape, sarray(), varray());
bind_string_method(validate_node_name, sarray(), varray());
Handle gltf binary [ Ignore and Warn | Extract Textures (default) | Optimize Loading Embedded as Basisu ] Enable compressed mip maps from Basis Universal for faster compressions. Increase the quality of Basis to avoid corruption. To keep compatibility use the first mip of the previous internal Godot format. Because texture names may have invalid filename characters, adds String::validate_filename to sanitize filenames for import pipeline use.
2022-07-18 17:58:27 -07:00
bind_string_method(validate_filename, sarray(), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
Add `String.is_valid_unicode_identifier()` - Adds `is_valid_unicode_identifier()` - Adds `is_valid_ascii_identifier()` - Deprecates `is_valid_identifier()` - Renames `validate_identifier()` to `validate_ascii_identifier()`
2024-08-23 14:30:51 +08:00
bind_string_method(is_valid_ascii_identifier, sarray(), varray());
bind_string_method(is_valid_unicode_identifier, sarray(), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(is_valid_identifier, sarray(), varray());
bind_string_method(is_valid_int, sarray(), varray());
bind_string_method(is_valid_float, sarray(), varray());
bind_string_method(is_valid_hex_number, sarray("with_prefix"), varray(false));
bind_string_method(is_valid_html_color, sarray(), varray());
bind_string_method(is_valid_ip_address, sarray(), varray());
bind_string_method(is_valid_filename, sarray(), varray());
bind_string_method(to_int, sarray(), varray());
bind_string_method(to_float, sarray(), varray());
bind_string_method(hex_to_int, sarray(), varray());
bind_string_method(bin_to_int, sarray(), varray());
bind_string_method(lpad, sarray("min_length", "character"), varray(" "));
bind_string_method(rpad, sarray("min_length", "character"), varray(" "));
bind_string_method(pad_decimals, sarray("digits"), varray());
bind_string_method(pad_zeros, sarray("digits"), varray());
Add const char * overloads to String class Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com>
2023-11-02 15:15:48 -04:00
bind_string_methodv(trim_prefix, static_cast<String (String::*)(const String &) const>(&String::trim_prefix), sarray("prefix"), varray());
bind_string_methodv(trim_suffix, static_cast<String (String::*)(const String &) const>(&String::trim_suffix), sarray("suffix"), varray());
Unify String and StringName
2022-12-05 21:46:47 -05:00
bind_string_method(to_ascii_buffer, sarray(), varray());
bind_string_method(to_utf8_buffer, sarray(), varray());
bind_string_method(to_utf16_buffer, sarray(), varray());
bind_string_method(to_utf32_buffer, sarray(), varray());
Add GDScript `to_wchar_buffer` and `get_string_from_wchar` functions.
2023-02-13 16:18:12 +02:00
bind_string_method(to_wchar_buffer, sarray(), varray());
Add methods to decode/encode multibyte encodings.
2024-09-13 09:19:26 +03:00
bind_string_method(to_multibyte_char_buffer, sarray("encoding"), varray(String()));
bind_string_method(hex_decode, sarray(), varray());
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 15:59:37 -03:00
Use Grisu2 algorithm in String::num_scientific to fix serializing
2024-11-01 02:02:09 -07:00
bind_static_methodv(String, num_scientific, static_cast<String (*)(double)>(&String::num_scientific), sarray("number"), varray());
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 10:56:34 -03:00
bind_static_method(String, num, sarray("number", "decimals"), varray(-1));
Unify TextServer built-in module and GDExtension code.
2022-02-13 14:41:29 +02:00
bind_static_method(String, num_int64, sarray("number", "base", "capitalize_hex"), varray(10, false));
bind_static_method(String, num_uint64, sarray("number", "base", "capitalize_hex"), varray(10, false));
GDScript: Re-add `ord()` function
2024-11-12 16:21:52 +03:00
bind_static_method(String, chr, sarray("code"), varray());
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 10:56:34 -03:00
bind_static_method(String, humanize_size, sarray("size"), varray());
[GDExtension] Expose Variant, NodePath and StringName hash functions.
2022-06-06 12:19:56 +03:00
/* StringName */
bind_method(StringName, hash, sarray(), varray());
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
}
[GDExtension] Expose Variant, NodePath and StringName hash functions.
2022-06-06 12:19:56 +03:00
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
static void _register_variant_builtin_methods_math() {
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
/* Vector2 */
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 15:59:37 -03:00
bind_method(Vector2, angle, sarray(), varray());
bind_method(Vector2, angle_to, sarray("to"), varray());
bind_method(Vector2, angle_to_point, sarray("to"), varray());
Rename Vector parameters to be consistent Renames parameters that were named differently across different scripting languages or their documentation to use the same name everywhere.
2021-11-29 18:02:42 +01:00
bind_method(Vector2, direction_to, sarray("to"), varray());
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 15:59:37 -03:00
bind_method(Vector2, distance_to, sarray("to"), varray());
bind_method(Vector2, distance_squared_to, sarray("to"), varray());
bind_method(Vector2, length, sarray(), varray());
bind_method(Vector2, length_squared, sarray(), varray());
Rename Vector2 clamped to limit_length and add limit_length to Vector3
2021-02-01 00:42:00 -05:00
bind_method(Vector2, limit_length, sarray("length"), varray(1.0));
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 15:59:37 -03:00
bind_method(Vector2, normalized, sarray(), varray());
bind_method(Vector2, is_normalized, sarray(), varray());
bind_method(Vector2, is_equal_approx, sarray("to"), varray());
Add `is_zero_approx` methods to `Vector2`, `3`, and `4`
2022-09-01 20:32:33 -04:00
bind_method(Vector2, is_zero_approx, sarray(), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Vector2, is_finite, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector2, posmod, sarray("mod"), varray());
bind_method(Vector2, posmodv, sarray("modv"), varray());
bind_method(Vector2, project, sarray("b"), varray());
Improve argument names for core types
2020-12-07 03:16:31 -05:00
bind_method(Vector2, lerp, sarray("to", "weight"), varray());
bind_method(Vector2, slerp, sarray("to", "weight"), varray());
bind_method(Vector2, cubic_interpolate, sarray("b", "pre_a", "post_b", "weight"), varray());
Make `cubic_interpolate()` consider key time in animation
2022-07-29 04:55:10 +09:00
bind_method(Vector2, cubic_interpolate_in_time, sarray("b", "pre_a", "post_b", "weight", "b_t", "pre_a_t", "post_b_t"), varray());
Refactor bezier interpolation functions
2022-06-27 19:41:32 +02:00
bind_method(Vector2, bezier_interpolate, sarray("control_1", "control_2", "end", "t"), varray());
Refactor Curve3D::_bake() method The main change is to caculate tangent directly from bezier curve, without going through discretized polyline, avoiding pitfalls of discretization. Other changes are: 1. Add an bezier_derivative() method for Vector3, Vector2, and Math; 2. Add an tesselate_even_length() method to Curve3D, which tesselate bezier curve to even length segments adaptively; 3. Cache the tangent vectors in baked_tangent_vector_cache;
2022-11-23 11:11:58 +08:00
bind_method(Vector2, bezier_derivative, sarray("control_1", "control_2", "end", "t"), varray());
Expose max_axis_index and max_axis_index for Vector2(i) Some cleanup with Vector3(i)'s methods so that it is consistent with Vector2, for example it returns enums internally (GDScript still gets ints).
2019-11-28 03:48:51 -05:00
bind_method(Vector2, max_axis_index, sarray(), varray());
bind_method(Vector2, min_axis_index, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector2, move_toward, sarray("to", "delta"), varray());
Core: Rename math 'phi' arguments to 'angle'
2022-05-05 13:25:04 +02:00
bind_method(Vector2, rotated, sarray("angle"), varray());
Rename Vector2.tangent() to Vector2.orthogonal()
2020-12-06 18:16:06 +00:00
bind_method(Vector2, orthogonal, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector2, floor, sarray(), varray());
bind_method(Vector2, ceil, sarray(), varray());
bind_method(Vector2, round, sarray(), varray());
bind_method(Vector2, aspect, sarray(), varray());
bind_method(Vector2, dot, sarray("with"), varray());
bind_method(Vector2, slide, sarray("n"), varray());
bind_method(Vector2, bounce, sarray("n"), varray());
Clarify bounce and reflect docs and update param names
2024-03-11 16:29:51 -07:00
bind_method(Vector2, reflect, sarray("line"), varray());
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 15:59:37 -03:00
bind_method(Vector2, cross, sarray("with"), varray());
bind_method(Vector2, abs, sarray(), varray());
bind_method(Vector2, sign, sarray(), varray());
Allow clamping vectors and colors
2021-02-01 00:10:52 -05:00
bind_method(Vector2, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector2, clampf, sarray("min", "max"), varray());
Rename Math::stepify to snapped
2020-12-21 18:02:57 +00:00
bind_method(Vector2, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector2, snappedf, sarray("step"), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector2, min, sarray("with"), varray());
bind_method(Vector2, minf, sarray("with"), varray());
bind_method(Vector2, max, sarray("with"), varray());
bind_method(Vector2, maxf, sarray("with"), varray());
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 15:59:37 -03:00
Add Vector2.from_angle() method
2021-04-27 15:53:04 +02:00
bind_static_method(Vector2, from_angle, sarray("angle"), varray());
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
/* Vector2i */
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 15:59:37 -03:00
bind_method(Vector2i, aspect, sarray(), varray());
Expose max_axis_index and max_axis_index for Vector2(i) Some cleanup with Vector3(i)'s methods so that it is consistent with Vector2, for example it returns enums internally (GDScript still gets ints).
2019-11-28 03:48:51 -05:00
bind_method(Vector2i, max_axis_index, sarray(), varray());
bind_method(Vector2i, min_axis_index, sarray(), varray());
Implement `Vector2i/3i/4i` methods: `distance_to` and `distance_squared_to`
2023-10-11 12:04:57 +02:00
bind_method(Vector2i, distance_to, sarray("to"), varray());
bind_method(Vector2i, distance_squared_to, sarray("to"), varray());
Add length and length_squared to Vector2i/3i
2021-11-29 11:13:31 -06:00
bind_method(Vector2i, length, sarray(), varray());
bind_method(Vector2i, length_squared, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector2i, sign, sarray(), varray());
bind_method(Vector2i, abs, sarray(), varray());
Allow clamping vectors and colors
2021-02-01 00:10:52 -05:00
bind_method(Vector2i, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector2i, clampi, sarray("min", "max"), varray());
Implement snappedi, snappedf, and Vector[2/3/4]i.snapped
2022-09-24 14:20:06 +02:00
bind_method(Vector2i, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector2i, snappedi, sarray("step"), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector2i, min, sarray("with"), varray());
bind_method(Vector2i, mini, sarray("with"), varray());
bind_method(Vector2i, max, sarray("with"), varray());
bind_method(Vector2i, maxi, sarray("with"), varray());
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 15:59:37 -03:00
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
/* Rect2 */
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 15:59:37 -03:00
Add Get Center Method for Rect2/Rect2i and AABB.
2021-09-21 00:33:52 +05:45
bind_method(Rect2, get_center, sarray(), varray());
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 15:59:37 -03:00
bind_method(Rect2, get_area, sarray(), varray());
Replace Rect2(i) has_no_area with has_area
2022-08-14 21:51:45 -05:00
bind_method(Rect2, has_area, sarray(), varray());
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 15:59:37 -03:00
bind_method(Rect2, has_point, sarray("point"), varray());
bind_method(Rect2, is_equal_approx, sarray("rect"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Rect2, is_finite, sarray(), varray());
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 15:59:37 -03:00
bind_method(Rect2, intersects, sarray("b", "include_borders"), varray(false));
bind_method(Rect2, encloses, sarray("b"), varray());
Rename Rect2 and Rect2i clip() to intersection()
2020-12-19 12:43:35 +00:00
bind_method(Rect2, intersection, sarray("b"), varray());
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 15:59:37 -03:00
bind_method(Rect2, merge, sarray("b"), varray());
bind_method(Rect2, expand, sarray("to"), varray());
Simplify and fix Rect2/AABB get_support function
2024-08-19 00:28:48 -07:00
bind_method(Rect2, get_support, sarray("direction"), varray());
Rename Rect2 and Rect2i grow_margin() to grow_side()
2020-12-28 09:11:58 +00:00
bind_method(Rect2, grow, sarray("amount"), varray());
bind_methodv(Rect2, grow_side, &Rect2::grow_side_bind, sarray("side", "amount"), varray());
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 15:59:37 -03:00
bind_method(Rect2, grow_individual, sarray("left", "top", "right", "bottom"), varray());
bind_method(Rect2, abs, sarray(), varray());
/* Rect2i */
Add Get Center Method for Rect2/Rect2i and AABB.
2021-09-21 00:33:52 +05:45
bind_method(Rect2i, get_center, sarray(), varray());
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 15:59:37 -03:00
bind_method(Rect2i, get_area, sarray(), varray());
Replace Rect2(i) has_no_area with has_area
2022-08-14 21:51:45 -05:00
bind_method(Rect2i, has_area, sarray(), varray());
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 15:59:37 -03:00
bind_method(Rect2i, has_point, sarray("point"), varray());
bind_method(Rect2i, intersects, sarray("b"), varray());
bind_method(Rect2i, encloses, sarray("b"), varray());
Rename Rect2 and Rect2i clip() to intersection()
2020-12-19 12:43:35 +00:00
bind_method(Rect2i, intersection, sarray("b"), varray());
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 15:59:37 -03:00
bind_method(Rect2i, merge, sarray("b"), varray());
bind_method(Rect2i, expand, sarray("to"), varray());
Rename Rect2 and Rect2i grow_margin() to grow_side()
2020-12-28 09:11:58 +00:00
bind_method(Rect2i, grow, sarray("amount"), varray());
bind_methodv(Rect2i, grow_side, &Rect2i::grow_side_bind, sarray("side", "amount"), varray());
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 15:59:37 -03:00
bind_method(Rect2i, grow_individual, sarray("left", "top", "right", "bottom"), varray());
bind_method(Rect2i, abs, sarray(), varray());
/* Vector3 */
Expose max_axis_index and max_axis_index for Vector2(i) Some cleanup with Vector3(i)'s methods so that it is consistent with Vector2, for example it returns enums internally (GDScript still gets ints).
2019-11-28 03:48:51 -05:00
bind_method(Vector3, min_axis_index, sarray(), varray());
bind_method(Vector3, max_axis_index, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector3, angle_to, sarray("to"), varray());
Added signed_angle_to for Vector3
2021-02-15 09:01:46 -05:00
bind_method(Vector3, signed_angle_to, sarray("to", "axis"), varray());
Rename Vector parameters to be consistent Renames parameters that were named differently across different scripting languages or their documentation to use the same name everywhere.
2021-11-29 18:02:42 +01:00
bind_method(Vector3, direction_to, sarray("to"), varray());
bind_method(Vector3, distance_to, sarray("to"), varray());
bind_method(Vector3, distance_squared_to, sarray("to"), varray());
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 15:59:37 -03:00
bind_method(Vector3, length, sarray(), varray());
bind_method(Vector3, length_squared, sarray(), varray());
Rename Vector2 clamped to limit_length and add limit_length to Vector3
2021-02-01 00:42:00 -05:00
bind_method(Vector3, limit_length, sarray("length"), varray(1.0));
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 15:59:37 -03:00
bind_method(Vector3, normalized, sarray(), varray());
bind_method(Vector3, is_normalized, sarray(), varray());
bind_method(Vector3, is_equal_approx, sarray("to"), varray());
Add `is_zero_approx` methods to `Vector2`, `3`, and `4`
2022-09-01 20:32:33 -04:00
bind_method(Vector3, is_zero_approx, sarray(), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Vector3, is_finite, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector3, inverse, sarray(), varray());
Allow clamping vectors and colors
2021-02-01 00:10:52 -05:00
bind_method(Vector3, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector3, clampf, sarray("min", "max"), varray());
Rename Math::stepify to snapped
2020-12-21 18:02:57 +00:00
bind_method(Vector3, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector3, snappedf, sarray("step"), varray());
Core: Rename math 'phi' arguments to 'angle'
2022-05-05 13:25:04 +02:00
bind_method(Vector3, rotated, sarray("axis", "angle"), varray());
Improve argument names for core types
2020-12-07 03:16:31 -05:00
bind_method(Vector3, lerp, sarray("to", "weight"), varray());
bind_method(Vector3, slerp, sarray("to", "weight"), varray());
bind_method(Vector3, cubic_interpolate, sarray("b", "pre_a", "post_b", "weight"), varray());
Make `cubic_interpolate()` consider key time in animation
2022-07-29 04:55:10 +09:00
bind_method(Vector3, cubic_interpolate_in_time, sarray("b", "pre_a", "post_b", "weight", "b_t", "pre_a_t", "post_b_t"), varray());
Refactor bezier interpolation functions
2022-06-27 19:41:32 +02:00
bind_method(Vector3, bezier_interpolate, sarray("control_1", "control_2", "end", "t"), varray());
Refactor Curve3D::_bake() method The main change is to caculate tangent directly from bezier curve, without going through discretized polyline, avoiding pitfalls of discretization. Other changes are: 1. Add an bezier_derivative() method for Vector3, Vector2, and Math; 2. Add an tesselate_even_length() method to Curve3D, which tesselate bezier curve to even length segments adaptively; 3. Cache the tangent vectors in baked_tangent_vector_cache;
2022-11-23 11:11:58 +08:00
bind_method(Vector3, bezier_derivative, sarray("control_1", "control_2", "end", "t"), varray());
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 15:59:37 -03:00
bind_method(Vector3, move_toward, sarray("to", "delta"), varray());
bind_method(Vector3, dot, sarray("with"), varray());
bind_method(Vector3, cross, sarray("with"), varray());
bind_method(Vector3, outer, sarray("with"), varray());
bind_method(Vector3, abs, sarray(), varray());
bind_method(Vector3, floor, sarray(), varray());
bind_method(Vector3, ceil, sarray(), varray());
bind_method(Vector3, round, sarray(), varray());
bind_method(Vector3, posmod, sarray("mod"), varray());
bind_method(Vector3, posmodv, sarray("modv"), varray());
bind_method(Vector3, project, sarray("b"), varray());
bind_method(Vector3, slide, sarray("n"), varray());
bind_method(Vector3, bounce, sarray("n"), varray());
Update the description and parameter name for Vector3 reflect to correct how the plane is constructed
2024-04-30 13:50:39 -07:00
bind_method(Vector3, reflect, sarray("n"), varray());
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 15:59:37 -03:00
bind_method(Vector3, sign, sarray(), varray());
Implement Animation Compression Roughly based on https://github.com/godotengine/godot-proposals/issues/3375 (used format is slightly different). * Implement bitwidth based animation compression (see animation.h for format). * Can compress imported animations up to 10 times. * Compression format opens the door to streaming. * Works transparently (happens all inside animation.h)
2021-10-20 20:42:22 -03:00
bind_method(Vector3, octahedron_encode, sarray(), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector3, min, sarray("with"), varray());
bind_method(Vector3, minf, sarray("with"), varray());
bind_method(Vector3, max, sarray("with"), varray());
bind_method(Vector3, maxf, sarray("with"), varray());
Implement Animation Compression Roughly based on https://github.com/godotengine/godot-proposals/issues/3375 (used format is slightly different). * Implement bitwidth based animation compression (see animation.h for format). * Can compress imported animations up to 10 times. * Compression format opens the door to streaming. * Works transparently (happens all inside animation.h)
2021-10-20 20:42:22 -03:00
bind_static_method(Vector3, octahedron_decode, sarray("uv"), varray());
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 15:59:37 -03:00
/* Vector3i */
Expose max_axis_index and max_axis_index for Vector2(i) Some cleanup with Vector3(i)'s methods so that it is consistent with Vector2, for example it returns enums internally (GDScript still gets ints).
2019-11-28 03:48:51 -05:00
bind_method(Vector3i, min_axis_index, sarray(), varray());
bind_method(Vector3i, max_axis_index, sarray(), varray());
Implement `Vector2i/3i/4i` methods: `distance_to` and `distance_squared_to`
2023-10-11 12:04:57 +02:00
bind_method(Vector3i, distance_to, sarray("to"), varray());
bind_method(Vector3i, distance_squared_to, sarray("to"), varray());
Add length and length_squared to Vector2i/3i
2021-11-29 11:13:31 -06:00
bind_method(Vector3i, length, sarray(), varray());
bind_method(Vector3i, length_squared, sarray(), varray());
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 15:59:37 -03:00
bind_method(Vector3i, sign, sarray(), varray());
bind_method(Vector3i, abs, sarray(), varray());
Allow clamping vectors and colors
2021-02-01 00:10:52 -05:00
bind_method(Vector3i, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector3i, clampi, sarray("min", "max"), varray());
Implement snappedi, snappedf, and Vector[2/3/4]i.snapped
2022-09-24 14:20:06 +02:00
bind_method(Vector3i, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector3i, snappedi, sarray("step"), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector3i, min, sarray("with"), varray());
bind_method(Vector3i, mini, sarray("with"), varray());
bind_method(Vector3i, max, sarray("with"), varray());
bind_method(Vector3i, maxi, sarray("with"), varray());
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 15:59:37 -03:00
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 */
bind_method(Vector4, min_axis_index, sarray(), varray());
bind_method(Vector4, max_axis_index, sarray(), varray());
bind_method(Vector4, length, sarray(), varray());
bind_method(Vector4, length_squared, sarray(), varray());
bind_method(Vector4, abs, sarray(), varray());
Add some missing Vector4 methods
2022-07-25 22:49:18 +02:00
bind_method(Vector4, sign, sarray(), varray());
bind_method(Vector4, floor, sarray(), varray());
bind_method(Vector4, ceil, sarray(), varray());
bind_method(Vector4, round, sarray(), varray());
bind_method(Vector4, lerp, sarray("to", "weight"), varray());
Vector4/Vector4i: Add missing methods, tests and fix change of sign operator
2022-08-07 12:25:05 +02:00
bind_method(Vector4, cubic_interpolate, sarray("b", "pre_a", "post_b", "weight"), varray());
Make `cubic_interpolate()` consider key time in animation
2022-07-29 04:55:10 +09:00
bind_method(Vector4, cubic_interpolate_in_time, sarray("b", "pre_a", "post_b", "weight", "b_t", "pre_a_t", "post_b_t"), varray());
Vector4/Vector4i: Add missing methods, tests and fix change of sign operator
2022-08-07 12:25:05 +02:00
bind_method(Vector4, posmod, sarray("mod"), varray());
bind_method(Vector4, posmodv, sarray("modv"), varray());
bind_method(Vector4, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector4, snappedf, sarray("step"), varray());
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
bind_method(Vector4, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector4, clampf, sarray("min", "max"), varray());
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
bind_method(Vector4, normalized, sarray(), varray());
bind_method(Vector4, is_normalized, sarray(), varray());
Vector4/Vector4i: Add missing methods, tests and fix change of sign operator
2022-08-07 12:25:05 +02:00
bind_method(Vector4, direction_to, sarray("to"), varray());
bind_method(Vector4, distance_to, sarray("to"), varray());
vector4 distance_squared_to and update csharp
2022-08-08 17:05:55 +02:00
bind_method(Vector4, distance_squared_to, sarray("to"), varray());
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
bind_method(Vector4, dot, sarray("with"), varray());
bind_method(Vector4, inverse, sarray(), varray());
Unify descriptions of vector methods * is_equal_approx * normalize * length_squared * posmod * posmodv
2023-04-14 14:39:35 +08:00
bind_method(Vector4, is_equal_approx, sarray("to"), varray());
Add `is_zero_approx` methods to `Vector2`, `3`, and `4`
2022-09-01 20:32:33 -04:00
bind_method(Vector4, is_zero_approx, sarray(), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Vector4, is_finite, sarray(), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector4, min, sarray("with"), varray());
bind_method(Vector4, minf, sarray("with"), varray());
bind_method(Vector4, max, sarray("with"), varray());
bind_method(Vector4, maxf, sarray("with"), varray());
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
/* Vector4i */
bind_method(Vector4i, min_axis_index, sarray(), varray());
bind_method(Vector4i, max_axis_index, sarray(), varray());
bind_method(Vector4i, length, sarray(), varray());
bind_method(Vector4i, length_squared, sarray(), varray());
bind_method(Vector4i, sign, sarray(), varray());
bind_method(Vector4i, abs, sarray(), varray());
bind_method(Vector4i, clamp, sarray("min", "max"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector4i, clampi, sarray("min", "max"), varray());
Implement snappedi, snappedf, and Vector[2/3/4]i.snapped
2022-09-24 14:20:06 +02:00
bind_method(Vector4i, snapped, sarray("step"), varray());
[Core] Add scalar versions of `Vector*` `min/max/clamp/snap(ped)` Convenience for a number of cases operating on single values
2024-03-03 14:37:52 +01:00
bind_method(Vector4i, snappedi, sarray("step"), varray());
Expose `Vector*` component-wise and scalar `min/max` to scripting
2024-05-02 10:45:15 +02:00
bind_method(Vector4i, min, sarray("with"), varray());
bind_method(Vector4i, mini, sarray("with"), varray());
bind_method(Vector4i, max, sarray("with"), varray());
bind_method(Vector4i, maxi, sarray("with"), varray());
Implement `Vector2i/3i/4i` methods: `distance_to` and `distance_squared_to`
2023-10-11 12:04:57 +02:00
bind_method(Vector4i, distance_to, sarray("to"), varray());
bind_method(Vector4i, distance_squared_to, sarray("to"), varray());
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
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 15:59:37 -03:00
/* Plane */
bind_method(Plane, normalized, sarray(), varray());
Rename `center` method to `get_center` in Plane.
2023-01-15 16:51:43 +01:00
bind_method(Plane, get_center, sarray(), varray());
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 15:59:37 -03:00
bind_method(Plane, is_equal_approx, sarray("to_plane"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Plane, is_finite, sarray(), varray());
Solve discrepancy between code and class reference for Plane On #43310, class reference was automatically updated from source, causing xml documentation to disagree with parameter naming description on Plane.intersects_segment(). Weirdly, it also changed the parameter for Plane.is_point_over() from point to plane, when only the first has sense (and it is defined on math.Plane as "const Vector3 &p_point"). Manual mistake? * Update begin/end to from/to on Plane.intersects_segment(...) docs description to match source * Update Plane bindings to use points instread of plane for is_point_over(...) * Change Plane.is_point_over(plane) to Plane.is_point_over(point) AND its description on docs Fixes godotengine/godot-docs#5976
2022-07-24 11:30:32 +02:00
bind_method(Plane, is_point_over, sarray("point"), varray());
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 15:59:37 -03:00
bind_method(Plane, distance_to, sarray("point"), varray());
Rename `epsilon` to `tolerance` in the `Plane::has_point` method
2022-07-21 19:34:09 +03:00
bind_method(Plane, has_point, sarray("point", "tolerance"), varray(CMP_EPSILON));
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 15:59:37 -03:00
bind_method(Plane, project, sarray("point"), varray());
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 13:16:08 -03:00
bind_methodv(Plane, intersect_3, &Plane::intersect_3_bind, sarray("b", "c"), varray());
bind_methodv(Plane, intersects_ray, &Plane::intersects_ray_bind, sarray("from", "dir"), varray());
bind_methodv(Plane, intersects_segment, &Plane::intersects_segment_bind, sarray("from", "to"), varray());
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 15:59:37 -03:00
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
/* Quaternion */
bind_method(Quaternion, length, sarray(), varray());
bind_method(Quaternion, length_squared, sarray(), varray());
bind_method(Quaternion, normalized, sarray(), varray());
bind_method(Quaternion, is_normalized, sarray(), varray());
bind_method(Quaternion, is_equal_approx, sarray("to"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Quaternion, is_finite, sarray(), varray());
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
bind_method(Quaternion, inverse, sarray(), varray());
Fix blend animation to solve TRS track bug & blend order inconsistency
2022-03-16 01:35:25 +09:00
bind_method(Quaternion, log, sarray(), varray());
bind_method(Quaternion, exp, sarray(), varray());
Add Quaternion angle_to method
2020-12-07 01:40:46 -05:00
bind_method(Quaternion, angle_to, sarray("to"), varray());
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
bind_method(Quaternion, dot, sarray("with"), varray());
bind_method(Quaternion, slerp, sarray("to", "weight"), varray());
bind_method(Quaternion, slerpni, sarray("to", "weight"), varray());
rename and unify notation for spherical interpolation
2022-07-27 21:27:51 +09:00
bind_method(Quaternion, spherical_cubic_interpolate, sarray("b", "pre_a", "post_b", "weight"), varray());
Make `cubic_interpolate()` consider key time in animation
2022-07-29 04:55:10 +09:00
bind_method(Quaternion, spherical_cubic_interpolate_in_time, sarray("b", "pre_a", "post_b", "weight", "b_t", "pre_a_t", "post_b_t"), varray());
Allow getting Quaternion rotation in different Euler orders
2022-10-01 21:54:19 -05:00
bind_method(Quaternion, get_euler, sarray("order"), varray((int64_t)EulerOrder::YXZ));
Replace Quaternion Euler constructor with `from_euler` method
2022-11-01 08:11:09 -05:00
bind_static_method(Quaternion, from_euler, sarray("euler"), varray());
Implement Animation Compression Roughly based on https://github.com/godotengine/godot-proposals/issues/3375 (used format is slightly different). * Implement bitwidth based animation compression (see animation.h for format). * Can compress imported animations up to 10 times. * Compression format opens the door to streaming. * Works transparently (happens all inside animation.h)
2021-10-20 20:42:22 -03:00
bind_method(Quaternion, get_axis, sarray(), varray());
bind_method(Quaternion, get_angle, sarray(), varray());
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 15:59:37 -03:00
/* Color */
bind_method(Color, to_argb32, sarray(), varray());
bind_method(Color, to_abgr32, sarray(), varray());
bind_method(Color, to_rgba32, sarray(), varray());
bind_method(Color, to_argb64, sarray(), varray());
bind_method(Color, to_abgr64, sarray(), varray());
bind_method(Color, to_rgba64, sarray(), varray());
Color: Bind `from_hsv` as static method
2021-11-11 09:01:39 +01:00
bind_method(Color, to_html, sarray("with_alpha"), varray(true));
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 15:59:37 -03:00
Allow clamping vectors and colors
2021-02-01 00:10:52 -05:00
bind_method(Color, clamp, sarray("min", "max"), varray(Color(0, 0, 0, 0), Color(1, 1, 1, 1)));
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 15:59:37 -03:00
bind_method(Color, inverted, sarray(), varray());
Improve argument names for core types
2020-12-07 03:16:31 -05:00
bind_method(Color, lerp, sarray("to", "weight"), varray());
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 15:59:37 -03:00
bind_method(Color, lightened, sarray("amount"), varray());
bind_method(Color, darkened, sarray("amount"), varray());
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 12:29:59 -03:00
bind_method(Color, blend, sarray("over"), varray());
Fix font preview text color on light background
2021-12-16 13:59:04 +08:00
bind_method(Color, get_luminance, sarray(), varray());
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
bind_method(Color, srgb_to_linear, sarray(), varray());
bind_method(Color, linear_to_srgb, sarray(), varray());
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 15:59:37 -03:00
bind_method(Color, is_equal_approx, sarray("to"), varray());
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 10:56:34 -03:00
bind_static_method(Color, hex, sarray("hex"), varray());
bind_static_method(Color, hex64, sarray("hex"), varray());
bind_static_method(Color, html, sarray("rgba"), varray());
bind_static_method(Color, html_is_valid, sarray("color"), varray());
Add Color.from_rgba8 and deprecate Color8
2024-12-26 13:02:37 +01:00
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
bind_static_method(Color, from_string, sarray("str", "default"), varray());
Color: Bind `from_hsv` as static method
2021-11-11 09:01:39 +01:00
bind_static_method(Color, from_hsv, sarray("h", "s", "v", "alpha"), varray(1.0));
Allow picking similar colours using OKHSL.
2022-04-18 11:29:29 -07:00
bind_static_method(Color, from_ok_hsl, sarray("h", "s", "l", "alpha"), varray(1.0));
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 10:56:34 -03:00
bind_static_method(Color, from_rgbe9995, sarray("rgbe"), varray());
Add Color.from_rgba8 and deprecate Color8
2024-12-26 13:02:37 +01:00
bind_static_method(Color, from_rgba8, sarray("r8", "g8", "b8", "a8"), varray(255));
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
}
Add static method support to core Variant types * Properly exposed, including validated and variant call * Bound static functions in String and Color * Did not add support for scripting languages, will have to be added manually.
2021-02-24 10:56:34 -03:00
Enhance bindings of deep resource duplication
2025-06-20 17:55:15 +02:00
VARIANT_ENUM_CAST(ResourceDeepDuplicateMode);
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
static void _register_variant_builtin_methods_misc() {
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 15:59:37 -03:00
/* RID */
[GDExtension] Add binds for missing methods, operators, and constants required for GDExtension TextServer implementation.
2022-02-08 09:49:14 +02:00
bind_method(RID, is_valid, sarray(), varray());
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 13:16:08 -03:00
bind_method(RID, get_id, sarray(), varray());
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 15:59:37 -03:00
/* NodePath */
bind_method(NodePath, is_absolute, sarray(), varray());
bind_method(NodePath, get_name_count, sarray(), varray());
bind_method(NodePath, get_name, sarray("idx"), varray());
bind_method(NodePath, get_subname_count, sarray(), varray());
[GDExtension] Expose Variant, NodePath and StringName hash functions.
2022-06-06 12:19:56 +03:00
bind_method(NodePath, hash, sarray(), varray());
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 15:59:37 -03:00
bind_method(NodePath, get_subname, sarray("idx"), varray());
implement bone renamer in importer
2022-06-27 17:06:50 +09:00
bind_method(NodePath, get_concatenated_names, sarray(), varray());
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 15:59:37 -03:00
bind_method(NodePath, get_concatenated_subnames, sarray(), varray());
Added NodePath::slice method.
2023-09-17 14:38:44 -04:00
bind_method(NodePath, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(NodePath, get_as_property_path, sarray(), varray());
bind_method(NodePath, is_empty, sarray(), varray());
/* Callable */
Core: Add `Callable.create` static method for `Variant` callables
2024-02-28 12:53:34 +03:00
bind_static_method(Callable, create, sarray("variant", "method"), varray());
Callable: add callv method This method can be called from GDExtension.
2022-09-20 22:32:46 +02:00
bind_method(Callable, callv, sarray("arguments"), varray());
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 15:59:37 -03:00
bind_method(Callable, is_null, sarray(), varray());
bind_method(Callable, is_custom, sarray(), varray());
bind_method(Callable, is_standard, sarray(), varray());
Add Callable.is_valid() analogous to FuncRef.is_valid() from 3.x
2021-06-30 07:36:46 -07:00
bind_method(Callable, is_valid, sarray(), varray());
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 15:59:37 -03:00
bind_method(Callable, get_object, sarray(), varray());
bind_method(Callable, get_object_id, sarray(), varray());
bind_method(Callable, get_method, sarray(), varray());
Add methods to get argument count of methods Added to: * `Callable`s * `Object`s * `ClassDB` * `Script(Instance)`s
2024-01-28 15:16:09 +01:00
bind_function(Callable, get_argument_count, _VariantCall::func_Callable_get_argument_count, sarray(), varray());
Properly report Callable bound arguments Fixes #63213 Adds a function: Callable::get_amount_of_arguments_bound() to query this in callables. Exposed to the engine API.
2023-01-06 15:37:53 +01:00
bind_method(Callable, get_bound_arguments_count, sarray(), varray());
Fix Callable call error reporting. * Fix potential crash when using bind in `Variant::get_callable_error_text()` * Properly compute bound arguments so they can be properly shown. * Add a function to obtain the actual bound arguments.
2023-01-10 13:08:10 +01:00
bind_method(Callable, get_bound_arguments, sarray(), varray());
Core: Fix `Callable.get_bound_arguments{,_count}()` return incorrect data
2024-11-01 02:28:21 +03:00
bind_method(Callable, get_unbound_arguments_count, sarray(), varray());
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 15:59:37 -03:00
bind_method(Callable, hash, sarray(), varray());
Allow binding Callable arguments from an array Restores 3.x functionality that was removed in the Signal/Callable refactor of 4.0. Fixes #64668. Implements https://github.com/godotengine/godot-proposals/issues/6034 Usage: ```GDScript callable.bindv([arg1,arg2,arg3]) ```
2023-01-06 16:35:42 +01:00
bind_method(Callable, bindv, sarray("arguments"), varray());
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 15:59:37 -03:00
bind_method(Callable, unbind, sarray("argcount"), varray());
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 13:16:08 -03:00
bind_custom(Callable, call, _VariantCall::func_Callable_call, true, Variant);
bind_custom(Callable, call_deferred, _VariantCall::func_Callable_call_deferred, false, Variant);
Add RPC to Callable -Up to each scripting language to implement this -If not supported for the function, it will just error when you try to call
2021-05-03 18:00:44 -03:00
bind_custom(Callable, rpc, _VariantCall::func_Callable_rpc, false, Variant);
bind_custom1(Callable, rpc_id, _VariantCall::func_Callable_rpc_id, Variant::INT, "peer_id");
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 13:16:08 -03:00
bind_custom(Callable, bind, _VariantCall::func_Callable_bind, true, Callable);
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 15:59:37 -03:00
/* Signal */
bind_method(Signal, is_null, sarray(), varray());
bind_method(Signal, get_object, sarray(), varray());
bind_method(Signal, get_object_id, sarray(), varray());
bind_method(Signal, get_name, sarray(), varray());
Remove binds from Signal.connect
2021-09-19 18:55:23 +02:00
bind_method(Signal, connect, sarray("callable", "flags"), varray(0));
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 15:59:37 -03:00
bind_method(Signal, disconnect, sarray("callable"), varray());
bind_method(Signal, is_connected, sarray("callable"), varray());
bind_method(Signal, get_connections, sarray(), varray());
[Core] Add way to check if a signal has any connections Added to `Object` and `Signal`
2024-01-18 17:20:56 +01:00
bind_method(Signal, has_connections, sarray(), varray());
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 15:59:37 -03: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 13:16:08 -03:00
bind_custom(Signal, emit, _VariantCall::func_Signal_emit, false, Variant);
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 15:59:37 -03:00
/* Transform2D */
bind_method(Transform2D, inverse, sarray(), varray());
bind_method(Transform2D, affine_inverse, sarray(), varray());
bind_method(Transform2D, get_rotation, sarray(), varray());
bind_method(Transform2D, get_origin, sarray(), varray());
bind_method(Transform2D, get_scale, sarray(), varray());
Expose get_skew for transform2d and add new constructor Expose set_scale and set_skew for transform2d Replacing float by real_t Adding const parameters Updated transform2d doc
2021-09-02 11:36:19 +02:00
bind_method(Transform2D, get_skew, sarray(), varray());
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 15:59:37 -03:00
bind_method(Transform2D, orthonormalized, sarray(), varray());
Core: Rename math 'phi' arguments to 'angle'
2022-05-05 13:25:04 +02:00
bind_method(Transform2D, rotated, sarray("angle"), varray());
Fix consistency of translated/scaled/rotated in Transform2D and Transform3D
2022-07-30 12:17:33 +02:00
bind_method(Transform2D, rotated_local, sarray("angle"), varray());
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 15:59:37 -03:00
bind_method(Transform2D, scaled, sarray("scale"), varray());
Fix consistency of translated/scaled/rotated in Transform2D and Transform3D
2022-07-30 12:17:33 +02:00
bind_method(Transform2D, scaled_local, sarray("scale"), varray());
bind_method(Transform2D, translated, sarray("offset"), varray());
rename translate(d) to translate(d)_local in Transform 2D/3D
2022-07-16 11:47:54 +02:00
bind_method(Transform2D, translated_local, sarray("offset"), varray());
Expose `determinant` in Transform2D, rename internal method
2023-04-21 01:21:59 -05:00
bind_method(Transform2D, determinant, sarray(), varray());
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 15:59:37 -03:00
bind_method(Transform2D, basis_xform, sarray("v"), varray());
bind_method(Transform2D, basis_xform_inv, sarray("v"), varray());
Improve argument names for core types
2020-12-07 03:16:31 -05:00
bind_method(Transform2D, interpolate_with, sarray("xform", "weight"), varray());
Add `is_conformal` method to Basis and Transform2D
2023-09-07 09:43:22 -05:00
bind_method(Transform2D, is_conformal, sarray(), varray());
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 15:59:37 -03:00
bind_method(Transform2D, is_equal_approx, sarray("xform"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Transform2D, is_finite, sarray(), varray());
Unbind Variant methods that change immutable types. Fixes #62706. Code is commented instead of removed to clarify why they should not be re-added.
2023-01-06 15:14:39 +01:00
// Do not bind functions like set_rotation, set_scale, set_skew, etc because this type is immutable and can't be modified.
Fix a few default parameters in bindings They have the wrong type and cause issues with extensions.
2021-07-29 10:42:05 -03:00
bind_method(Transform2D, looking_at, sarray("target"), varray(Vector2()));
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 15:59:37 -03:00
/* Basis */
bind_method(Basis, inverse, sarray(), varray());
bind_method(Basis, transposed, sarray(), varray());
bind_method(Basis, orthonormalized, sarray(), varray());
bind_method(Basis, determinant, sarray(), varray());
Core: Rename math 'phi' arguments to 'angle'
2022-05-05 13:25:04 +02:00
bind_methodv(Basis, rotated, static_cast<Basis (Basis::*)(const Vector3 &, real_t) const>(&Basis::rotated), sarray("axis", "angle"), varray());
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 15:59:37 -03:00
bind_method(Basis, scaled, sarray("scale"), varray());
Optimized and exposed Basis::scaled_local.
2025-01-14 17:38:40 -06:00
bind_method(Basis, scaled_local, sarray("scale"), varray());
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 15:59:37 -03:00
bind_method(Basis, get_scale, sarray(), varray());
Move EulerOrder enum to math_defs.h and global scope
2022-10-01 21:53:12 -05:00
bind_method(Basis, get_euler, sarray("order"), varray((int64_t)EulerOrder::YXZ));
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 15:59:37 -03:00
bind_method(Basis, tdotx, sarray("with"), varray());
bind_method(Basis, tdoty, sarray("with"), varray());
bind_method(Basis, tdotz, sarray("with"), varray());
Improve argument names for core types
2020-12-07 03:16:31 -05:00
bind_method(Basis, slerp, sarray("to", "weight"), varray());
Add `is_conformal` method to Basis and Transform2D
2023-09-07 09:43:22 -05:00
bind_method(Basis, is_conformal, sarray(), varray());
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 15:59:37 -03:00
bind_method(Basis, is_equal_approx, sarray("b"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Basis, is_finite, sarray(), varray());
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
bind_method(Basis, get_rotation_quaternion, sarray(), varray());
Add the ability to look-at in model-space. This is a much simpler attempt to solve the same problem as #76060, but without breaking any compatibility. * Adds a description of what model space is in the Vector3 enums (MODEL_* constants). This has the proper axes laid out for imported 3D assets. * Adds the option to `look_at` using model_space, which uses Vector3.MODEL_FRONT as forward vector. The attempt of this PR is to still break the assumption that there is a single direction of forward (which is not the case in Godot) and make it easier to understand where 3D models are facing, as well as orienting them via look_at.
2023-04-15 10:01:43 +02:00
bind_static_method(Basis, looking_at, sarray("target", "up", "use_model_front"), varray(Vector3(0, 1, 0), false));
Replace Vector3.to_diagonal_matrix with Basis.from_scale
2021-09-06 15:39:01 -05:00
bind_static_method(Basis, from_scale, sarray("scale"), varray());
Move EulerOrder enum to math_defs.h and global scope
2022-10-01 21:53:12 -05:00
bind_static_method(Basis, from_euler, sarray("euler", "order"), varray((int64_t)EulerOrder::YXZ));
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 15:59:37 -03:00
/* AABB */
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 13:16:08 -03:00
bind_method(AABB, abs, sarray(), varray());
Add Get Center Method for Rect2/Rect2i and AABB.
2021-09-21 00:33:52 +05:45
bind_method(AABB, get_center, sarray(), varray());
Rename AABB `get_area` to `get_volume`
2021-11-04 21:01:59 -04:00
bind_method(AABB, get_volume, sarray(), varray());
Replace AABB has_no_volume with has_volume Also replace has_no_surface with has_surface
2022-08-14 21:48:13 -05:00
bind_method(AABB, has_volume, sarray(), varray());
bind_method(AABB, has_surface, sarray(), varray());
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 13:16:08 -03:00
bind_method(AABB, has_point, sarray("point"), varray());
bind_method(AABB, is_equal_approx, sarray("aabb"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(AABB, is_finite, sarray(), varray());
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 13:16:08 -03:00
bind_method(AABB, intersects, sarray("with"), varray());
bind_method(AABB, encloses, sarray("with"), varray());
bind_method(AABB, intersects_plane, sarray("plane"), varray());
bind_method(AABB, intersection, sarray("with"), varray());
bind_method(AABB, merge, sarray("with"), varray());
bind_method(AABB, expand, sarray("to_point"), varray());
bind_method(AABB, grow, sarray("by"), varray());
Simplify and fix Rect2/AABB get_support function
2024-08-19 00:28:48 -07:00
bind_method(AABB, get_support, sarray("direction"), varray());
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 13:16:08 -03:00
bind_method(AABB, get_longest_axis, sarray(), varray());
bind_method(AABB, get_longest_axis_index, sarray(), varray());
bind_method(AABB, get_longest_axis_size, sarray(), varray());
bind_method(AABB, get_shortest_axis, sarray(), varray());
bind_method(AABB, get_shortest_axis_index, sarray(), varray());
bind_method(AABB, get_shortest_axis_size, sarray(), varray());
bind_method(AABB, get_endpoint, sarray("idx"), varray());
bind_methodv(AABB, intersects_segment, &AABB::intersects_segment_bind, sarray("from", "to"), varray());
bind_methodv(AABB, intersects_ray, &AABB::intersects_ray_bind, sarray("from", "dir"), varray());
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 15:59:37 -03:00
Rename Transform to Transform3D in core
2020-10-17 01:08:21 -04:00
/* Transform3D */
bind_method(Transform3D, inverse, sarray(), varray());
bind_method(Transform3D, affine_inverse, sarray(), varray());
bind_method(Transform3D, orthonormalized, sarray(), varray());
Core: Rename math 'phi' arguments to 'angle'
2022-05-05 13:25:04 +02:00
bind_method(Transform3D, rotated, sarray("axis", "angle"), varray());
Fix consistency of translated/scaled/rotated in Transform2D and Transform3D
2022-07-30 12:17:33 +02:00
bind_method(Transform3D, rotated_local, sarray("axis", "angle"), varray());
Rename Transform to Transform3D in core
2020-10-17 01:08:21 -04:00
bind_method(Transform3D, scaled, sarray("scale"), varray());
Fix consistency of translated/scaled/rotated in Transform2D and Transform3D
2022-07-30 12:17:33 +02:00
bind_method(Transform3D, scaled_local, sarray("scale"), varray());
bind_method(Transform3D, translated, sarray("offset"), varray());
rename translate(d) to translate(d)_local in Transform 2D/3D
2022-07-16 11:47:54 +02:00
bind_method(Transform3D, translated_local, sarray("offset"), varray());
Add the ability to look-at in model-space. This is a much simpler attempt to solve the same problem as #76060, but without breaking any compatibility. * Adds a description of what model space is in the Vector3 enums (MODEL_* constants). This has the proper axes laid out for imported 3D assets. * Adds the option to `look_at` using model_space, which uses Vector3.MODEL_FRONT as forward vector. The attempt of this PR is to still break the assumption that there is a single direction of forward (which is not the case in Godot) and make it easier to understand where 3D models are facing, as well as orienting them via look_at.
2023-04-15 10:01:43 +02:00
bind_method(Transform3D, looking_at, sarray("target", "up", "use_model_front"), varray(Vector3(0, 1, 0), false));
Rename Transform to Transform3D in core
2020-10-17 01:08:21 -04:00
bind_method(Transform3D, interpolate_with, sarray("xform", "weight"), varray());
bind_method(Transform3D, is_equal_approx, sarray("xform"), varray());
Add `is_finite` method for checking built-in types
2022-08-11 16:12:27 +08:00
bind_method(Transform3D, is_finite, sarray(), varray());
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 15:59:37 -03:00
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 */
bind_static_method(Projection, create_depth_correction, sarray("flip_y"), varray());
bind_static_method(Projection, create_light_atlas_rect, sarray("rect"), varray());
bind_static_method(Projection, create_perspective, sarray("fovy", "aspect", "z_near", "z_far", "flip_fov"), varray(false));
Fix bind " convergence_dist" containing space
2023-01-23 19:55:30 +01:00
bind_static_method(Projection, create_perspective_hmd, sarray("fovy", "aspect", "z_near", "z_far", "flip_fov", "eye", "intraocular_dist", "convergence_dist"), varray());
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
bind_static_method(Projection, create_for_hmd, sarray("eye", "aspect", "intraocular_dist", "display_width", "display_to_lens", "oversample", "z_near", "z_far"), varray());
bind_static_method(Projection, create_orthogonal, sarray("left", "right", "bottom", "top", "z_near", "z_far"), varray());
bind_static_method(Projection, create_orthogonal_aspect, sarray("size", "aspect", "z_near", "z_far", "flip_fov"), varray(false));
bind_static_method(Projection, create_frustum, sarray("left", "right", "bottom", "top", "z_near", "z_far"), varray());
bind_static_method(Projection, create_frustum_aspect, sarray("size", "aspect", "offset", "z_near", "z_far", "flip_fov"), varray(false));
bind_static_method(Projection, create_fit_aabb, sarray("aabb"), varray());
bind_method(Projection, determinant, sarray(), varray());
bind_method(Projection, perspective_znear_adjusted, sarray("new_znear"), varray());
bind_method(Projection, get_projection_plane, sarray("plane"), varray());
bind_method(Projection, flipped_y, sarray(), varray());
bind_method(Projection, jitter_offseted, sarray("offset"), varray());
bind_static_method(Projection, get_fovy, sarray("fovx", "aspect"), varray());
bind_method(Projection, get_z_far, sarray(), varray());
bind_method(Projection, get_z_near, sarray(), varray());
bind_method(Projection, get_aspect, sarray(), varray());
bind_method(Projection, get_fov, sarray(), varray());
bind_method(Projection, is_orthogonal, sarray(), varray());
bind_method(Projection, get_viewport_half_extents, sarray(), varray());
bind_method(Projection, get_far_plane_half_extents, sarray(), varray());
bind_method(Projection, inverse, sarray(), varray());
bind_method(Projection, get_pixels_per_meter, sarray("for_pixel_width"), varray());
bind_method(Projection, get_lod_multiplier, sarray(), varray());
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 15:59:37 -03:00
/* Dictionary */
bind_method(Dictionary, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(Dictionary, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(Dictionary, clear, sarray(), varray());
Implement typed dictionaries
2023-06-24 13:03:28 -05:00
bind_method(Dictionary, assign, sarray("dictionary"), varray());
Add a sort method to Dictionary and HashMap
2023-05-17 19:52:44 -05:00
bind_method(Dictionary, sort, sarray(), varray());
Add Dictionary.merge()
2022-04-04 18:46:55 +02:00
bind_method(Dictionary, merge, sarray("dictionary", "overwrite"), varray(false));
Allow returning Dictionary after merging
2022-09-08 18:14:10 +02:00
bind_method(Dictionary, merged, sarray("dictionary", "overwrite"), varray(false));
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 15:59:37 -03:00
bind_method(Dictionary, has, sarray("key"), varray());
bind_method(Dictionary, has_all, sarray("keys"), varray());
Add Dictionary.find_key()
2022-08-05 19:08:27 +02:00
bind_method(Dictionary, find_key, sarray("value"), varray());
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 15:59:37 -03:00
bind_method(Dictionary, erase, sarray("key"), varray());
bind_method(Dictionary, hash, sarray(), varray());
bind_method(Dictionary, keys, sarray(), varray());
bind_method(Dictionary, values, sarray(), varray());
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 12:29:59 -03:00
bind_method(Dictionary, duplicate, sarray("deep"), varray(false));
Overhaul `Variant::duplicate()` for resources This in the scope of a duplication triggered via any type in the `Variant` realm. that is, the following: `Variant` itself, `Array` and `Dictionary`. That includes invoking `duplicate()` from scripts. A `duplicate_deep(deep_subresources_mode)` method is added to `Variant`, `Array` and `Dictionary` (for compatibility reasons, simply adding an extra parameter was not possible). The default value for it is `RESOURCE_DEEP_DUPLICATE_NONE`, which is like calling `duplicate(true)`. Remarks: - The results of copying resources via those `Variant` types are exactly the same as if the copy were initiated from the `Resource` type at C++. - In order to keep some separation between `Variant` and the higher-level animal which is `Resource`, `Variant` still contains the original code for that, so it's self-sufficient unless there's a `Resource` involved. Once the deep copy finds a `Resource` that has to be copied according to the duplication parameters, the algorithm invokes the `Resource` duplication machinery. When the stack is unwind back to a nesting level `Variant` can handle, `Variant` duplication logic keeps functioning. While that is good from a responsibility separation standpoint, that would have a caveat: `Variant` would not be aware of the mapping between original and duplicate subresources and so wouldn't be able to keep preventing multiple duplicates. To avoid that, this commit also introduces a wormwhole, a sharing mechanism by which `Variant` and `Resource` can collaborate in managing the lifetime of the original-to-duplicates map. The user-visible benefit is that the overduplicate prevention works as broadly as the whole `Variant` entity being copied, including all nesting levels, regardless how disconnected the data members containing resources may be across al the nesting levels. In other words, despite the aforementioned division of duties between `Variant` and `Resource` duplication logic, the duplicates map is shared among them. It's created when first finding a `Resource` and, however how deep the copy was working at that point, the map kept alive unitl the stack is unwind to the root user call, until the first step of the recursion. Thanks to that common map of duplicates, this commit is able to fix the issue that `Resource::duplicate_for_local_scene()` used to ignore overridden duplicate logic.
2025-01-21 11:55:23 +01:00
bind_method(Dictionary, duplicate_deep, sarray("deep_subresources_mode"), varray(RESOURCE_DEEP_DUPLICATE_INTERNAL));
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 15:59:37 -03:00
bind_method(Dictionary, get, sarray("key", "default"), varray(Variant()));
Add a `get_or_add` method to Dictionary
2023-06-10 15:13:38 -05:00
bind_method(Dictionary, get_or_add, sarray("key", "default"), varray(Variant()));
Bind Array get and set functions
2024-08-21 19:26:21 -07:00
bind_method(Dictionary, set, sarray("key", "value"), varray());
Implement typed dictionaries
2023-06-24 13:03:28 -05:00
bind_method(Dictionary, is_typed, sarray(), varray());
bind_method(Dictionary, is_typed_key, sarray(), varray());
bind_method(Dictionary, is_typed_value, sarray(), varray());
bind_method(Dictionary, is_same_typed, sarray("dictionary"), varray());
bind_method(Dictionary, is_same_typed_key, sarray("dictionary"), varray());
bind_method(Dictionary, is_same_typed_value, sarray("dictionary"), varray());
bind_method(Dictionary, get_typed_key_builtin, sarray(), varray());
bind_method(Dictionary, get_typed_value_builtin, sarray(), varray());
bind_method(Dictionary, get_typed_key_class_name, sarray(), varray());
bind_method(Dictionary, get_typed_value_class_name, sarray(), varray());
bind_method(Dictionary, get_typed_key_script, sarray(), varray());
bind_method(Dictionary, get_typed_value_script, sarray(), varray());
GDScript: Fix test for read-only state of constants
2023-01-22 11:07:48 +02:00
bind_method(Dictionary, make_read_only, sarray(), varray());
bind_method(Dictionary, is_read_only, sarray(), varray());
[TextServer, GDExtension] Fix building text servers as GDExtension, expose new/changed low-level methods to GDExtension API.
2024-06-02 21:21:18 +03:00
bind_method(Dictionary, recursive_equal, sarray("dictionary", "recursion_count"), varray());
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
}
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 15:59:37 -03:00
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
static void _register_variant_builtin_methods_array() {
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 15:59:37 -03:00
/* Array */
bind_method(Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(Array, clear, sarray(), varray());
bind_method(Array, hash, sarray(), varray());
GDScript: Fix issues with typed arrays
2022-11-27 09:56:53 +02:00
bind_method(Array, assign, sarray("array"), varray());
Add bound checks to `Array`/`Packed*Array` variant call `get` and `set` methods.
2025-02-27 17:43:40 +02:00
bind_function(Array, get, _VariantCall::func_Array_get, sarray("index"), varray());
bind_functionnc(Array, set, _VariantCall::func_Array_set, sarray("index", "value"), varray());
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 15:59:37 -03:00
bind_method(Array, push_back, sarray("value"), varray());
bind_method(Array, push_front, sarray("value"), varray());
bind_method(Array, append, sarray("value"), varray());
Add append_array() method to Array class
2020-11-08 21:09:45 +01:00
bind_method(Array, append_array, sarray("array"), varray());
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 15:59:37 -03:00
bind_method(Array, resize, sarray("size"), varray());
bind_method(Array, insert, sarray("position", "value"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(Array, remove_at, sarray("position"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(Array, fill, sarray("value"), varray());
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 15:59:37 -03:00
bind_method(Array, erase, sarray("value"), varray());
bind_method(Array, front, sarray(), varray());
bind_method(Array, back, sarray(), varray());
add ability to pick random value from array
2022-10-15 09:43:16 -03:00
bind_method(Array, pick_random, sarray(), varray());
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 15:59:37 -03:00
bind_method(Array, find, sarray("what", "from"), varray(0));
Add callable support for `find` and `rfind` `Array` methods
2024-08-11 23:28:32 -07:00
bind_method(Array, find_custom, sarray("method", "from"), varray(0));
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 15:59:37 -03:00
bind_method(Array, rfind, sarray("what", "from"), varray(-1));
Add callable support for `find` and `rfind` `Array` methods
2024-08-11 23:28:32 -07:00
bind_method(Array, rfind_custom, sarray("method", "from"), varray(-1));
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 15:59:37 -03:00
bind_method(Array, count, sarray("value"), varray());
bind_method(Array, has, sarray("value"), varray());
bind_method(Array, pop_back, sarray(), varray());
bind_method(Array, pop_front, sarray(), varray());
Add an `Array.pop_at()` method to pop an element at an arbitrary index Negative indices are supported to pop an element relative from the end.
2021-08-27 00:51:17 +02:00
bind_method(Array, pop_at, sarray("position"), varray());
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 15:59:37 -03:00
bind_method(Array, sort, sarray(), varray());
Change sort_custom/bsearch_custom to use Callables
2021-02-04 02:02:06 +01:00
bind_method(Array, sort_custom, sarray("func"), varray());
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 15:59:37 -03:00
bind_method(Array, shuffle, sarray(), varray());
bind_method(Array, bsearch, sarray("value", "before"), varray(true));
Change sort_custom/bsearch_custom to use Callables
2021-02-04 02:02:06 +01:00
bind_method(Array, bsearch_custom, sarray("value", "func", "before"), varray(true));
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(Array, reverse, sarray(), varray());
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 12:29:59 -03:00
bind_method(Array, duplicate, sarray("deep"), varray(false));
Overhaul `Variant::duplicate()` for resources This in the scope of a duplication triggered via any type in the `Variant` realm. that is, the following: `Variant` itself, `Array` and `Dictionary`. That includes invoking `duplicate()` from scripts. A `duplicate_deep(deep_subresources_mode)` method is added to `Variant`, `Array` and `Dictionary` (for compatibility reasons, simply adding an extra parameter was not possible). The default value for it is `RESOURCE_DEEP_DUPLICATE_NONE`, which is like calling `duplicate(true)`. Remarks: - The results of copying resources via those `Variant` types are exactly the same as if the copy were initiated from the `Resource` type at C++. - In order to keep some separation between `Variant` and the higher-level animal which is `Resource`, `Variant` still contains the original code for that, so it's self-sufficient unless there's a `Resource` involved. Once the deep copy finds a `Resource` that has to be copied according to the duplication parameters, the algorithm invokes the `Resource` duplication machinery. When the stack is unwind back to a nesting level `Variant` can handle, `Variant` duplication logic keeps functioning. While that is good from a responsibility separation standpoint, that would have a caveat: `Variant` would not be aware of the mapping between original and duplicate subresources and so wouldn't be able to keep preventing multiple duplicates. To avoid that, this commit also introduces a wormwhole, a sharing mechanism by which `Variant` and `Resource` can collaborate in managing the lifetime of the original-to-duplicates map. The user-visible benefit is that the overduplicate prevention works as broadly as the whole `Variant` entity being copied, including all nesting levels, regardless how disconnected the data members containing resources may be across al the nesting levels. In other words, despite the aforementioned division of duties between `Variant` and `Resource` duplication logic, the duplicates map is shared among them. It's created when first finding a `Resource` and, however how deep the copy was working at that point, the map kept alive unitl the stack is unwind to the root user call, until the first step of the recursion. Thanks to that common map of duplicates, this commit is able to fix the issue that `Resource::duplicate_for_local_scene()` used to ignore overridden duplicate logic.
2025-01-21 11:55:23 +01:00
bind_method(Array, duplicate_deep, sarray("deep_subresources_mode"), varray(RESOURCE_DEEP_DUPLICATE_INTERNAL));
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(Array, slice, sarray("begin", "end", "step", "deep"), varray(INT_MAX, 1, false));
Add filter, map and reduce to Array
2020-10-19 21:21:16 +02:00
bind_method(Array, filter, sarray("method"), varray());
bind_method(Array, map, sarray("method"), varray());
bind_method(Array, reduce, sarray("method", "accum"), varray(Variant()));
Add `any()` and `all()` methods to Array These can be used as faster, more convenient shorthands to using `filter()` + `size()`.
2021-07-10 20:19:47 +02:00
bind_method(Array, any, sarray("method"), varray());
bind_method(Array, all, sarray("method"), varray());
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 15:59:37 -03:00
bind_method(Array, max, sarray(), varray());
bind_method(Array, min, sarray(), varray());
[GDExtension] Implement support for typed arrays.
2022-08-25 12:35:30 +03:00
bind_method(Array, is_typed, sarray(), varray());
GDScript: Fix issues with typed arrays
2022-11-27 09:56:53 +02:00
bind_method(Array, is_same_typed, sarray("array"), varray());
[GDExtension] Implement support for typed arrays.
2022-08-25 12:35:30 +03:00
bind_method(Array, get_typed_builtin, sarray(), varray());
bind_method(Array, get_typed_class_name, sarray(), varray());
bind_method(Array, get_typed_script, sarray(), varray());
GDScript: Fix test for read-only state of constants
2023-01-22 11:07:48 +02:00
bind_method(Array, make_read_only, sarray(), varray());
[GDExtension] Implement support for typed arrays.
2022-08-25 12:35:30 +03:00
bind_method(Array, is_read_only, sarray(), varray());
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 15:59:37 -03:00
Add bound checks to `Array`/`Packed*Array` variant call `get` and `set` methods.
2025-02-27 17:43:40 +02:00
/* Packed*Array get/set (see VARCALL_ARRAY_GETTER_SETTER macro) */
Bind Array get and set functions
2024-08-21 19:26:21 -07:00
bind_function(PackedByteArray, get, _VariantCall::func_PackedByteArray_get, sarray("index"), varray());
bind_function(PackedColorArray, get, _VariantCall::func_PackedColorArray_get, sarray("index"), varray());
bind_function(PackedFloat32Array, get, _VariantCall::func_PackedFloat32Array_get, sarray("index"), varray());
bind_function(PackedFloat64Array, get, _VariantCall::func_PackedFloat64Array_get, sarray("index"), varray());
bind_function(PackedInt32Array, get, _VariantCall::func_PackedInt32Array_get, sarray("index"), varray());
bind_function(PackedInt64Array, get, _VariantCall::func_PackedInt64Array_get, sarray("index"), varray());
bind_function(PackedStringArray, get, _VariantCall::func_PackedStringArray_get, sarray("index"), varray());
bind_function(PackedVector2Array, get, _VariantCall::func_PackedVector2Array_get, sarray("index"), varray());
bind_function(PackedVector3Array, get, _VariantCall::func_PackedVector3Array_get, sarray("index"), varray());
bind_function(PackedVector4Array, get, _VariantCall::func_PackedVector4Array_get, sarray("index"), varray());
Add bound checks to `Array`/`Packed*Array` variant call `get` and `set` methods.
2025-02-27 17:43:40 +02:00
bind_functionnc(PackedByteArray, set, _VariantCall::func_PackedByteArray_set, sarray("index", "value"), varray());
bind_functionnc(PackedColorArray, set, _VariantCall::func_PackedColorArray_set, sarray("index", "value"), varray());
bind_functionnc(PackedFloat32Array, set, _VariantCall::func_PackedFloat32Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedFloat64Array, set, _VariantCall::func_PackedFloat64Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedInt32Array, set, _VariantCall::func_PackedInt32Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedInt64Array, set, _VariantCall::func_PackedInt64Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedStringArray, set, _VariantCall::func_PackedStringArray_set, sarray("index", "value"), varray());
bind_functionnc(PackedVector2Array, set, _VariantCall::func_PackedVector2Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedVector3Array, set, _VariantCall::func_PackedVector3Array_set, sarray("index", "value"), varray());
bind_functionnc(PackedVector4Array, set, _VariantCall::func_PackedVector4Array_set, sarray("index", "value"), varray());
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 15:59:37 -03:00
/* Byte Array */
bind_method(PackedByteArray, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedByteArray, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedByteArray, push_back, sarray("value"), varray());
bind_method(PackedByteArray, append, sarray("value"), varray());
bind_method(PackedByteArray, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedByteArray, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedByteArray, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedByteArray, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedByteArray, resize, &PackedByteArray::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedByteArray, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedByteArray, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedByteArray, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedByteArray, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedByteArray, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedByteArray, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedByteArray, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedByteArray, find, sarray("value", "from"), varray(0));
bind_method(PackedByteArray, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedByteArray, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedByteArray, erase, sarray("value"), varray());
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 15:59:37 -03: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 13:16:08 -03:00
bind_function(PackedByteArray, get_string_from_ascii, _VariantCall::func_PackedByteArray_get_string_from_ascii, sarray(), varray());
bind_function(PackedByteArray, get_string_from_utf8, _VariantCall::func_PackedByteArray_get_string_from_utf8, sarray(), varray());
bind_function(PackedByteArray, get_string_from_utf16, _VariantCall::func_PackedByteArray_get_string_from_utf16, sarray(), varray());
bind_function(PackedByteArray, get_string_from_utf32, _VariantCall::func_PackedByteArray_get_string_from_utf32, sarray(), varray());
Add GDScript `to_wchar_buffer` and `get_string_from_wchar` functions.
2023-02-13 16:18:12 +02:00
bind_function(PackedByteArray, get_string_from_wchar, _VariantCall::func_PackedByteArray_get_string_from_wchar, sarray(), varray());
Add methods to decode/encode multibyte encodings.
2024-09-13 09:19:26 +03:00
bind_function(PackedByteArray, get_string_from_multibyte_char, _VariantCall::func_PackedByteArray_get_string_from_multibyte_char, sarray("encoding"), varray(String()));
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 13:16:08 -03:00
bind_function(PackedByteArray, hex_encode, _VariantCall::func_PackedByteArray_hex_encode, sarray(), varray());
bind_function(PackedByteArray, compress, _VariantCall::func_PackedByteArray_compress, sarray("compression_mode"), varray(0));
bind_function(PackedByteArray, decompress, _VariantCall::func_PackedByteArray_decompress, sarray("buffer_size", "compression_mode"), varray(0));
bind_function(PackedByteArray, decompress_dynamic, _VariantCall::func_PackedByteArray_decompress_dynamic, sarray("max_output_size", "compression_mode"), varray(0));
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 15:59:37 -03:00
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
bind_function(PackedByteArray, decode_u8, _VariantCall::func_PackedByteArray_decode_u8, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_s8, _VariantCall::func_PackedByteArray_decode_s8, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_u16, _VariantCall::func_PackedByteArray_decode_u16, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_s16, _VariantCall::func_PackedByteArray_decode_s16, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_u32, _VariantCall::func_PackedByteArray_decode_u32, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_s32, _VariantCall::func_PackedByteArray_decode_s32, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_u64, _VariantCall::func_PackedByteArray_decode_u64, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_s64, _VariantCall::func_PackedByteArray_decode_s64, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_half, _VariantCall::func_PackedByteArray_decode_half, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_float, _VariantCall::func_PackedByteArray_decode_float, sarray("byte_offset"), varray());
bind_function(PackedByteArray, decode_double, _VariantCall::func_PackedByteArray_decode_double, sarray("byte_offset"), varray());
bind_function(PackedByteArray, has_encoded_var, _VariantCall::func_PackedByteArray_has_encoded_var, sarray("byte_offset", "allow_objects"), varray(false));
bind_function(PackedByteArray, decode_var, _VariantCall::func_PackedByteArray_decode_var, sarray("byte_offset", "allow_objects"), varray(false));
bind_function(PackedByteArray, decode_var_size, _VariantCall::func_PackedByteArray_decode_var_size, sarray("byte_offset", "allow_objects"), varray(false));
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
bind_function(PackedByteArray, to_int32_array, _VariantCall::func_PackedByteArray_decode_s32_array, sarray(), varray());
bind_function(PackedByteArray, to_int64_array, _VariantCall::func_PackedByteArray_decode_s64_array, sarray(), varray());
bind_function(PackedByteArray, to_float32_array, _VariantCall::func_PackedByteArray_decode_float_array, sarray(), varray());
bind_function(PackedByteArray, to_float64_array, _VariantCall::func_PackedByteArray_decode_double_array, sarray(), varray());
Add PackedByteArray conversion to PackedVector2Array, PackedVector3Array, PackedVector4Array and PackedColorArray
2023-04-15 12:33:55 +03:00
bind_function(PackedByteArray, to_vector2_array, _VariantCall::func_PackedByteArray_decode_vector2_array, sarray(), varray());
bind_function(PackedByteArray, to_vector3_array, _VariantCall::func_PackedByteArray_decode_vector3_array, sarray(), varray());
bind_function(PackedByteArray, to_vector4_array, _VariantCall::func_PackedByteArray_decode_vector4_array, sarray(), varray());
bind_function(PackedByteArray, to_color_array, _VariantCall::func_PackedByteArray_decode_color_array, sarray(), varray());
New to_***_array method to decode PackedByteArray to Packed***Array Documentation for new PackedByteArray::to_***_array methods Documentation for to_byte_array method for PackedInt32/Int64/Float32/Float64Array
2021-07-17 00:36:45 +02:00
Add bswap methods to the `PackedByteArray` bindings.
2025-04-08 10:39:29 +03:00
bind_functionnc(PackedByteArray, bswap16, _VariantCall::func_PackedByteArray_bswap16, sarray("offset", "count"), varray(0, -1));
bind_functionnc(PackedByteArray, bswap32, _VariantCall::func_PackedByteArray_bswap32, sarray("offset", "count"), varray(0, -1));
bind_functionnc(PackedByteArray, bswap64, _VariantCall::func_PackedByteArray_bswap64, sarray("offset", "count"), varray(0, -1));
Add marshalling to PackedByteArray -Decode/Encode functions for u8,s8,u16,s16,u32,s32,u64,s64,half,float,double,variant -Improved binder template to allow this Given in Godot 4.0 PackedByteArray is passed as reference, it is now possible to have these functions there, which makes the most sense.
2021-04-09 17:57:37 -03:00
bind_functionnc(PackedByteArray, encode_u8, _VariantCall::func_PackedByteArray_encode_u8, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_s8, _VariantCall::func_PackedByteArray_encode_s8, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_u16, _VariantCall::func_PackedByteArray_encode_u16, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_s16, _VariantCall::func_PackedByteArray_encode_s16, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_u32, _VariantCall::func_PackedByteArray_encode_u32, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_s32, _VariantCall::func_PackedByteArray_encode_s32, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_u64, _VariantCall::func_PackedByteArray_encode_u64, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_s64, _VariantCall::func_PackedByteArray_encode_s64, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_half, _VariantCall::func_PackedByteArray_encode_half, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_float, _VariantCall::func_PackedByteArray_encode_float, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_double, _VariantCall::func_PackedByteArray_encode_double, sarray("byte_offset", "value"), varray());
bind_functionnc(PackedByteArray, encode_var, _VariantCall::func_PackedByteArray_encode_var, sarray("byte_offset", "value", "allow_objects"), varray(false));
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 15:59:37 -03:00
/* Int32 Array */
bind_method(PackedInt32Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedInt32Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedInt32Array, push_back, sarray("value"), varray());
bind_method(PackedInt32Array, append, sarray("value"), varray());
bind_method(PackedInt32Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedInt32Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedInt32Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedInt32Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedInt32Array, resize, &PackedInt32Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedInt32Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedInt32Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedInt32Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedInt32Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedInt32Array, to_byte_array, sarray(), varray());
bind_method(PackedInt32Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedInt32Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedInt32Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedInt32Array, find, sarray("value", "from"), varray(0));
bind_method(PackedInt32Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedInt32Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedInt32Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Int64 Array */
bind_method(PackedInt64Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedInt64Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedInt64Array, push_back, sarray("value"), varray());
bind_method(PackedInt64Array, append, sarray("value"), varray());
bind_method(PackedInt64Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedInt64Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedInt64Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedInt64Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedInt64Array, resize, &PackedInt64Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedInt64Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedInt64Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedInt64Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedInt64Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedInt64Array, to_byte_array, sarray(), varray());
bind_method(PackedInt64Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedInt64Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedInt64Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedInt64Array, find, sarray("value", "from"), varray(0));
bind_method(PackedInt64Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedInt64Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedInt64Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Float32 Array */
bind_method(PackedFloat32Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedFloat32Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedFloat32Array, push_back, sarray("value"), varray());
bind_method(PackedFloat32Array, append, sarray("value"), varray());
bind_method(PackedFloat32Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedFloat32Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedFloat32Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedFloat32Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedFloat32Array, resize, &PackedFloat32Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedFloat32Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedFloat32Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedFloat32Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedFloat32Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedFloat32Array, to_byte_array, sarray(), varray());
bind_method(PackedFloat32Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedFloat32Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedFloat32Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedFloat32Array, find, sarray("value", "from"), varray(0));
bind_method(PackedFloat32Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedFloat32Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedFloat32Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Float64 Array */
bind_method(PackedFloat64Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedFloat64Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedFloat64Array, push_back, sarray("value"), varray());
bind_method(PackedFloat64Array, append, sarray("value"), varray());
bind_method(PackedFloat64Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedFloat64Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedFloat64Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedFloat64Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedFloat64Array, resize, &PackedFloat64Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedFloat64Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedFloat64Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedFloat64Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedFloat64Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedFloat64Array, to_byte_array, sarray(), varray());
bind_method(PackedFloat64Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedFloat64Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedFloat64Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedFloat64Array, find, sarray("value", "from"), varray(0));
bind_method(PackedFloat64Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedFloat64Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedFloat64Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* String Array */
bind_method(PackedStringArray, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedStringArray, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedStringArray, push_back, sarray("value"), varray());
bind_method(PackedStringArray, append, sarray("value"), varray());
bind_method(PackedStringArray, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedStringArray, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedStringArray, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedStringArray, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedStringArray, resize, &PackedStringArray::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedStringArray, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedStringArray, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedStringArray, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedStringArray, slice, sarray("begin", "end"), varray(INT_MAX));
Fix `PackedStringArray.to_byte_array()` to return UTF-8 encoded data instead of pointers.
2025-02-07 10:19:19 +02:00
bind_function(PackedStringArray, to_byte_array, _VariantCall::func_PackedStringArray_to_byte_array, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedStringArray, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedStringArray, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedStringArray, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedStringArray, find, sarray("value", "from"), varray(0));
bind_method(PackedStringArray, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedStringArray, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedStringArray, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Vector2 Array */
bind_method(PackedVector2Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedVector2Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedVector2Array, push_back, sarray("value"), varray());
bind_method(PackedVector2Array, append, sarray("value"), varray());
bind_method(PackedVector2Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedVector2Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedVector2Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedVector2Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedVector2Array, resize, &PackedVector2Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedVector2Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedVector2Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedVector2Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedVector2Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedVector2Array, to_byte_array, sarray(), varray());
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
bind_method(PackedVector2Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedVector2Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedVector2Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedVector2Array, find, sarray("value", "from"), varray(0));
bind_method(PackedVector2Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedVector2Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedVector2Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Vector3 Array */
bind_method(PackedVector3Array, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedVector3Array, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedVector3Array, push_back, sarray("value"), varray());
bind_method(PackedVector3Array, append, sarray("value"), varray());
bind_method(PackedVector3Array, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedVector3Array, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedVector3Array, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedVector3Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedVector3Array, resize, &PackedVector3Array::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedVector3Array, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedVector3Array, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedVector3Array, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedVector3Array, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedVector3Array, to_byte_array, sarray(), varray());
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
bind_method(PackedVector3Array, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedVector3Array, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedVector3Array, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedVector3Array, find, sarray("value", "from"), varray(0));
bind_method(PackedVector3Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedVector3Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedVector3Array, erase, sarray("value"), varray());
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 15:59:37 -03:00
/* Color Array */
bind_method(PackedColorArray, size, sarray(), varray());
Rename empty() to is_empty()
2020-12-15 12:04:21 +00:00
bind_method(PackedColorArray, is_empty, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedColorArray, push_back, sarray("value"), varray());
bind_method(PackedColorArray, append, sarray("value"), varray());
bind_method(PackedColorArray, append_array, sarray("array"), varray());
Rename `remove()` to `remove_at()` when removing by index
2021-07-03 16:17:03 -06:00
bind_method(PackedColorArray, remove_at, sarray("index"), varray());
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 15:59:37 -03:00
bind_method(PackedColorArray, insert, sarray("at_index", "value"), varray());
Add fill method to Arrays and PackedArrays
2021-02-25 11:10:39 -03:00
bind_method(PackedColorArray, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedColorArray, resize, &PackedColorArray::resize_initialized, sarray("new_size"), varray());
Expose clear method for packed arrays
2022-08-10 17:12:20 +08:00
bind_method(PackedColorArray, clear, sarray(), varray());
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 15:59:37 -03:00
bind_method(PackedColorArray, has, sarray("value"), varray());
Rename Array.invert() to Array.reverse() Does the same internally for List and Vector<>, which includes all PackedArray types.
2021-03-14 07:21:32 +00:00
bind_method(PackedColorArray, reverse, sarray(), varray());
`Array`: Relax `slice` bound checks to properly handle negative indices The same is done for `Vector` (and thus `Packed*Array`). `begin` and `end` can now take any value and will be clamped to `[-size(), size()]`. Negative values are a shorthand for indexing the array from the last element upward. `end` is given a default `INT_MAX` value (which will be clamped to `size()`) so that the `end` parameter can be omitted to go from `begin` to the max size of the array. This makes `slice` works similarly to numpy's and JavaScript's.
2022-01-10 13:56:55 +01:00
bind_method(PackedColorArray, slice, sarray("begin", "end"), varray(INT_MAX));
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 15:59:37 -03:00
bind_method(PackedColorArray, to_byte_array, sarray(), varray());
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
bind_method(PackedColorArray, sort, sarray(), varray());
Implement bsearch for Vector and Packed*Array
2021-09-19 18:13:09 +00:00
bind_method(PackedColorArray, bsearch, sarray("value", "before"), varray(true));
packed*arrays are pass by ref now. support duplicate and update documentation
2020-12-17 14:26:05 -06:00
bind_method(PackedColorArray, duplicate, sarray(), varray());
Add search methods for packed arrays * count() * find() * rfind()
2022-05-07 20:16:11 +08:00
bind_method(PackedColorArray, find, sarray("value", "from"), varray(0));
bind_method(PackedColorArray, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedColorArray, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedColorArray, erase, sarray("value"), varray());
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 07:51:34 -07:00
/* Vector4 Array */
bind_method(PackedVector4Array, size, sarray(), varray());
bind_method(PackedVector4Array, is_empty, sarray(), varray());
bind_method(PackedVector4Array, push_back, sarray("value"), varray());
bind_method(PackedVector4Array, append, sarray("value"), varray());
bind_method(PackedVector4Array, append_array, sarray("array"), varray());
bind_method(PackedVector4Array, remove_at, sarray("index"), varray());
bind_method(PackedVector4Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedVector4Array, fill, sarray("value"), varray());
Add `resize_initialized` and `resize_uninitialized` to `Vector`. These functions serve as replacements for `resize`, to make sure the caller understands whether elements need to be initialized 'by hand' after the call.
2025-05-23 00:20:22 +02:00
bind_methodv(PackedVector4Array, resize, &PackedVector4Array::resize_initialized, sarray("new_size"), varray());
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 07:51:34 -07:00
bind_method(PackedVector4Array, clear, sarray(), varray());
bind_method(PackedVector4Array, has, sarray("value"), varray());
bind_method(PackedVector4Array, reverse, sarray(), varray());
bind_method(PackedVector4Array, slice, sarray("begin", "end"), varray(INT_MAX));
bind_method(PackedVector4Array, to_byte_array, sarray(), varray());
bind_method(PackedVector4Array, sort, sarray(), varray());
bind_method(PackedVector4Array, bsearch, sarray("value", "before"), varray(true));
bind_method(PackedVector4Array, duplicate, sarray(), varray());
bind_method(PackedVector4Array, find, sarray("value", "from"), varray(0));
bind_method(PackedVector4Array, rfind, sarray("value", "from"), varray(-1));
bind_method(PackedVector4Array, count, sarray("value"), varray());
[Core] Expose `Packed*Array::erase`
2024-06-03 21:19:52 +02:00
bind_method(PackedVector4Array, erase, sarray("value"), varray());
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
}
Add PackedVector4Array Variant type Co-authored-by: A Thousand Ships <96648715+AThousandShips@users.noreply.github.com> Co-authored-by: Rémi Verschelde <rverschelde@gmail.com>
2024-04-08 07:51:34 -07:00
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
static void _register_variant_builtin_constants() {
doc: Sync classref with current source + fixup some bindings Includes various changes triggered by the refactoring of method bindings.
2020-11-04 15:38:26 +01:00
/* Register constants */
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
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 19:33:38 -03:00
int ncc = Color::get_named_color_count();
for (int i = 0; i < ncc; i++) {
_VariantCall::add_variant_constant(Variant::COLOR, Color::get_named_color_name(i), Color::get_named_color(i));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
}
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_X", Vector3::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_Y", Vector3::AXIS_Y);
_VariantCall::add_enum_constant(Variant::VECTOR3, "Axis", "AXIS_Z", Vector3::AXIS_Z);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "ZERO", Vector3(0, 0, 0));
add ONE constants to Vector2 and Vector3
2018-10-07 02:13:41 +08:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "ONE", Vector3(1, 1, 1));
Core: Use `Math` namespace for constants
2025-04-10 11:21:05 -05:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "INF", Vector3(Math::INF, Math::INF, Math::INF));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "LEFT", Vector3(-1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "RIGHT", Vector3(1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "UP", Vector3(0, 1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "DOWN", Vector3(0, -1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "FORWARD", Vector3(0, 0, -1));
_VariantCall::add_variant_constant(Variant::VECTOR3, "BACK", Vector3(0, 0, 1));
Add the ability to look-at in model-space. This is a much simpler attempt to solve the same problem as #76060, but without breaking any compatibility. * Adds a description of what model space is in the Vector3 enums (MODEL_* constants). This has the proper axes laid out for imported 3D assets. * Adds the option to `look_at` using model_space, which uses Vector3.MODEL_FRONT as forward vector. The attempt of this PR is to still break the assumption that there is a single direction of forward (which is not the case in Godot) and make it easier to understand where 3D models are facing, as well as orienting them via look_at.
2023-04-15 10:01:43 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_LEFT", Vector3(1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_RIGHT", Vector3(-1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_TOP", Vector3(0, 1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_BOTTOM", Vector3(0, -1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_FRONT", Vector3(0, 0, 1));
_VariantCall::add_variant_constant(Variant::VECTOR3, "MODEL_REAR", Vector3(0, 0, -1));
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
_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_X", Vector4::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_Y", Vector4::AXIS_Y);
_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_Z", Vector4::AXIS_Z);
_VariantCall::add_enum_constant(Variant::VECTOR4, "Axis", "AXIS_W", Vector4::AXIS_W);
Core: Fix built-in enum constant bindings
2024-11-22 14:03:21 +03:00
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
_VariantCall::add_variant_constant(Variant::VECTOR4, "ZERO", Vector4(0, 0, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR4, "ONE", Vector4(1, 1, 1, 1));
Core: Use `Math` namespace for constants
2025-04-10 11:21:05 -05:00
_VariantCall::add_variant_constant(Variant::VECTOR4, "INF", Vector4(Math::INF, Math::INF, Math::INF, Math::INF));
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
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_X", Vector3i::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_Y", Vector3i::AXIS_Y);
_VariantCall::add_enum_constant(Variant::VECTOR3I, "Axis", "AXIS_Z", Vector3i::AXIS_Z);
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
_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_X", Vector4i::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_Y", Vector4i::AXIS_Y);
_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_Z", Vector4i::AXIS_Z);
_VariantCall::add_enum_constant(Variant::VECTOR4I, "Axis", "AXIS_W", Vector4i::AXIS_W);
_VariantCall::add_variant_constant(Variant::VECTOR4I, "ZERO", Vector4i(0, 0, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR4I, "ONE", Vector4i(1, 1, 1, 1));
Add Vector2/3/4i.MAX and MIN
2023-09-16 16:40:21 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR4I, "MIN", Vector4i(INT32_MIN, INT32_MIN, INT32_MIN, INT32_MIN));
_VariantCall::add_variant_constant(Variant::VECTOR4I, "MAX", Vector4i(INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX));
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
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 00:26:41 -03:00
_VariantCall::add_variant_constant(Variant::VECTOR3I, "ZERO", Vector3i(0, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "ONE", Vector3i(1, 1, 1));
Add Vector2/3/4i.MAX and MIN
2023-09-16 16:40:21 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR3I, "MIN", Vector3i(INT32_MIN, INT32_MIN, INT32_MIN));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "MAX", Vector3i(INT32_MAX, INT32_MAX, INT32_MAX));
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 00:26:41 -03:00
_VariantCall::add_variant_constant(Variant::VECTOR3I, "LEFT", Vector3i(-1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "RIGHT", Vector3i(1, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "UP", Vector3i(0, 1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "DOWN", Vector3i(0, -1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "FORWARD", Vector3i(0, 0, -1));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "BACK", Vector3i(0, 0, 1));
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
_VariantCall::add_enum_constant(Variant::VECTOR2, "Axis", "AXIS_X", Vector2::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR2, "Axis", "AXIS_Y", Vector2::AXIS_Y);
_VariantCall::add_enum_constant(Variant::VECTOR2I, "Axis", "AXIS_X", Vector2i::AXIS_X);
_VariantCall::add_enum_constant(Variant::VECTOR2I, "Axis", "AXIS_Y", Vector2i::AXIS_Y);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "ZERO", Vector2(0, 0));
add ONE constants to Vector2 and Vector3
2018-10-07 02:13:41 +08:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "ONE", Vector2(1, 1));
Core: Use `Math` namespace for constants
2025-04-10 11:21:05 -05:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "INF", Vector2(Math::INF, Math::INF));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "LEFT", Vector2(-1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2, "RIGHT", Vector2(1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2, "UP", Vector2(0, -1));
_VariantCall::add_variant_constant(Variant::VECTOR2, "DOWN", Vector2(0, 1));
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 00:26:41 -03:00
_VariantCall::add_variant_constant(Variant::VECTOR2I, "ZERO", Vector2i(0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "ONE", Vector2i(1, 1));
Add Vector2/3/4i.MAX and MIN
2023-09-16 16:40:21 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR2I, "MIN", Vector2i(INT32_MIN, INT32_MIN));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "MAX", Vector2i(INT32_MAX, INT32_MAX));
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 00:26:41 -03:00
_VariantCall::add_variant_constant(Variant::VECTOR2I, "LEFT", Vector2i(-1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "RIGHT", Vector2i(1, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "UP", Vector2i(0, -1));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "DOWN", Vector2i(0, 1));
Add Basis constants and format Transform constants
2019-08-08 20:29:45 -07:00
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "IDENTITY", Transform2D());
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_X", Transform2D(-1, 0, 0, 1, 0, 0));
_VariantCall::add_variant_constant(Variant::TRANSFORM2D, "FLIP_Y", Transform2D(1, 0, 0, -1, 0, 0));
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
Transform3D identity_transform;
Rename Transform to Transform3D in core
2020-10-17 01:08:21 -04:00
Transform3D flip_x_transform = Transform3D(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
Transform3D flip_y_transform = Transform3D(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0);
Transform3D flip_z_transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0);
Rename Variant TRANSFORM to TRANSFORM3D Also _transform to _transform3d
2021-04-28 03:36:08 -04:00
_VariantCall::add_variant_constant(Variant::TRANSFORM3D, "IDENTITY", identity_transform);
_VariantCall::add_variant_constant(Variant::TRANSFORM3D, "FLIP_X", flip_x_transform);
_VariantCall::add_variant_constant(Variant::TRANSFORM3D, "FLIP_Y", flip_y_transform);
_VariantCall::add_variant_constant(Variant::TRANSFORM3D, "FLIP_Z", flip_z_transform);
Add Basis constants and format Transform constants
2019-08-08 20:29:45 -07:00
Remove redundant Variant-types initializations
2022-11-14 18:21:06 +01:00
Basis identity_basis;
Add Basis constants and format Transform constants
2019-08-08 20:29:45 -07:00
Basis flip_x_basis = Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1);
Basis flip_y_basis = Basis(1, 0, 0, 0, -1, 0, 0, 0, 1);
Basis flip_z_basis = Basis(1, 0, 0, 0, 1, 0, 0, 0, -1);
_VariantCall::add_variant_constant(Variant::BASIS, "IDENTITY", identity_basis);
_VariantCall::add_variant_constant(Variant::BASIS, "FLIP_X", flip_x_basis);
_VariantCall::add_variant_constant(Variant::BASIS, "FLIP_Y", flip_y_basis);
_VariantCall::add_variant_constant(Variant::BASIS, "FLIP_Z", flip_z_basis);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Rename Plane constants, add to Mono But I'm not tagging PR as [Core] or [Mono] due to it being a minor change anyway.
2018-08-21 01:34:34 -04:00
_VariantCall::add_variant_constant(Variant::PLANE, "PLANE_YZ", Plane(Vector3(1, 0, 0), 0));
_VariantCall::add_variant_constant(Variant::PLANE, "PLANE_XZ", Plane(Vector3(0, 1, 0), 0));
_VariantCall::add_variant_constant(Variant::PLANE, "PLANE_XY", Plane(Vector3(0, 0, 1), 0));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Rename Quat to Quaternion
2021-01-20 07:02:02 +00:00
_VariantCall::add_variant_constant(Variant::QUATERNION, "IDENTITY", Quaternion(0, 0, 0, 1));
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
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_NEAR", Projection::PLANE_NEAR);
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_FAR", Projection::PLANE_FAR);
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_LEFT", Projection::PLANE_LEFT);
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_TOP", Projection::PLANE_TOP);
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_RIGHT", Projection::PLANE_RIGHT);
_VariantCall::add_enum_constant(Variant::PROJECTION, "Planes", "PLANE_BOTTOM", Projection::PLANE_BOTTOM);
Projection p;
_VariantCall::add_variant_constant(Variant::PROJECTION, "IDENTITY", p);
p.set_zero();
_VariantCall::add_variant_constant(Variant::PROJECTION, "ZERO", p);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03: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 13:16:08 -03:00
void Variant::_register_variant_methods() {
[Windows] Fix 32-bit MinGW LTO build.
2024-06-04 13:46:03 +03:00
_register_variant_builtin_methods_string();
_register_variant_builtin_methods_math();
_register_variant_builtin_methods_misc();
_register_variant_builtin_methods_array();
_register_variant_builtin_constants();
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 13:16:08 -03:00
}
Refactored variant constructor logic
2020-11-09 00:19:09 -03:00
void Variant::_unregister_variant_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 15:59:37 -03:00
//clear methods
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 13:16:08 -03:00
memdelete_arr(builtin_method_names);
memdelete_arr(builtin_method_info);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
memdelete_arr(_VariantCall::constant_data);
Add core types enums description to extension api json
2022-04-18 20:17:03 +02:00
memdelete_arr(_VariantCall::enum_data);
GODOT IS OPEN SOURCE
2014-02-09 22:10:30 -03:00
}
Reference in a new issue Copy permalink