maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
godot/core/variant/variant_call.cpp

1623 lines
69 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* variant_call.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/*************************************************************************/
Update copyright statements to 2020 Happy new year to the wonderful Godot community! We're starting a new decade with a well-established, non-profit, free and open source game engine, and tons of further improvements in the pipeline from hundreds of contributors. Godot will keep getting better, and we're looking forward to all the games that the community will keep developing and releasing with it.
2020-01-01 11:16:22 +01:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-05 00:50:27 +01:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
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/core_string_names.h"
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"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/object/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"
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/templates/oa_hash_map.h"
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
typedef void (*VariantFunc)(Variant &r_ret, Variant &p_self, const Variant **p_args);
typedef void (*VariantConstructFunc)(Variant &r_ret, const Variant **p_args);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
template <class T>
struct TypeAdjust {
_FORCE_INLINE_ static void adjust(Variant *r_ret) {
VariantTypeChanger<typename GetSimpleTypeT<T>::type_t>::change(r_ret);
}
};
template <> //do nothing for variant
struct TypeAdjust<Variant> {
_FORCE_INLINE_ static void adjust(Variant *r_ret) {
}
};
template <> //do nothing for variant
struct TypeAdjust<Object *> {
_FORCE_INLINE_ static void adjust(Variant *r_ret) {
VariantInternal::clear(r_ret);
*r_ret = (Object *)nullptr;
}
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
struct _VariantCall {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
template <class T, class... P>
class InternalMethod : public Variant::InternalMethod {
public:
void (T::*method)(P...);
Vector<Variant> default_values;
#ifdef DEBUG_ENABLED
Vector<String> argument_names;
#endif
Fix release build. (II)
2016-08-31 18:19:31 +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 20:59:37 +02:00
virtual int get_argument_count() const {
return sizeof...(P);
}
virtual Variant::Type get_argument_type(int p_arg) const {
return call_get_argument_type<P...>(p_arg);
}
#ifdef DEBUG_ENABLED
virtual String get_argument_name(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_names.size(), String());
return argument_names[p_arg];
}
#endif
virtual Vector<Variant> get_default_arguments() const {
return default_values;
}
Added difference between function which return value or not Now ADDFUNC with suffix R add function with return value. It was changed because addfunc considers that the function doesn't return a value if it returns NIL.
2017-10-22 19:08:16 +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 20:59:37 +02:00
virtual Variant::Type get_return_type() const {
return Variant::NIL;
}
virtual uint32_t get_flags() const {
return 0;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
call_with_variant_args_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_error, default_values);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
call_with_validated_variant_args(base, method, p_args);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
#ifdef PTRCALL_ENABLED
virtual void ptrcall(void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args<T, P...>(reinterpret_cast<T *>(p_base), method, p_args);
}
#endif
InternalMethod(void (T::*p_method)(P...), const Vector<Variant> &p_default_args
#ifdef DEBUG_ENABLED
,
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
const Vector<String> &p_arg_names, const StringName &p_method_name, Variant::Type p_base_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 20:59:37 +02:00
#endif
) {
method = p_method;
default_values = p_default_args;
#ifdef DEBUG_ENABLED
argument_names = p_arg_names;
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
method_name = p_method_name;
base_type = p_base_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 20:59:37 +02:00
#endif
}
};
template <class T, class R, class... P>
class InternalMethodR : public Variant::InternalMethod {
public:
R(T::*method)
(P...);
Vector<Variant> default_values;
#ifdef DEBUG_ENABLED
Vector<String> argument_names;
#endif
virtual int get_argument_count() const {
return sizeof...(P);
}
virtual Variant::Type get_argument_type(int p_arg) const {
return call_get_argument_type<P...>(p_arg);
return Variant::NIL;
}
#ifdef DEBUG_ENABLED
virtual String get_argument_name(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_names.size(), String());
return argument_names[p_arg];
}
#endif
virtual Vector<Variant> get_default_arguments() const {
return default_values;
}
virtual Variant::Type get_return_type() const {
return GetTypeInfo<R>::VARIANT_TYPE;
}
virtual uint32_t get_flags() const {
uint32_t f = 0;
if (get_return_type() == Variant::NIL) {
f |= FLAG_RETURNS_VARIANT;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
return f;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
call_with_variant_args_ret_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, default_values);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
TypeAdjust<R>::adjust(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 20:59:37 +02:00
call_with_validated_variant_args_ret(base, method, p_args, r_ret);
}
#ifdef PTRCALL_ENABLED
virtual void ptrcall(void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_ret<T, R, P...>(reinterpret_cast<T *>(p_base), method, p_args, r_ret);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
InternalMethodR(R (T::*p_method)(P...), const Vector<Variant> &p_default_args
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
,
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
const Vector<String> &p_arg_names, const StringName &p_method_name, Variant::Type p_base_type
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
) {
method = p_method;
default_values = p_default_args;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
argument_names = p_arg_names;
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
method_name = p_method_name;
base_type = p_base_type;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
}
};
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
template <class T, class R, class... P>
class InternalMethodRC : public Variant::InternalMethod {
public:
R(T::*method)
(P...) const;
Vector<Variant> default_values;
#ifdef DEBUG_ENABLED
Vector<String> argument_names;
#endif
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual int get_argument_count() const {
return sizeof...(P);
}
virtual Variant::Type get_argument_type(int p_arg) const {
return call_get_argument_type<P...>(p_arg);
}
#ifdef DEBUG_ENABLED
virtual String get_argument_name(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_names.size(), String());
return argument_names[p_arg];
}
#endif
virtual Vector<Variant> get_default_arguments() const {
return default_values;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
virtual Variant::Type get_return_type() const {
return GetTypeInfo<R>::VARIANT_TYPE;
}
virtual uint32_t get_flags() const {
uint32_t f = FLAG_IS_CONST;
if (get_return_type() == Variant::NIL) {
f |= FLAG_RETURNS_VARIANT;
}
return f;
}
Moved JSON functions to built-in to_json, parse_json, validate_json
2017-01-09 02:40:00 +01: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 20:59:37 +02:00
virtual void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
call_with_variant_args_retc_dv(VariantGetInternalPtr<T>::get_ptr(base), method, p_args, p_argcount, r_ret, r_error, default_values);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
}
Moved JSON functions to built-in to_json, parse_json, validate_json
2017-01-09 02:40:00 +01: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 20:59:37 +02:00
virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
TypeAdjust<R>::adjust(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 20:59:37 +02:00
call_with_validated_variant_args_retc(base, method, p_args, r_ret);
}
#ifdef PTRCALL_ENABLED
virtual void ptrcall(void *p_base, const void **p_args, void *r_ret) {
call_with_ptr_args_retc<T, R, P...>(reinterpret_cast<T *>(p_base), method, p_args, r_ret);
}
#endif
InternalMethodRC(R (T::*p_method)(P...) const, const Vector<Variant> &p_default_args
#ifdef DEBUG_ENABLED
,
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
const Vector<String> &p_arg_names, const StringName &p_method_name, Variant::Type p_base_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 20:59:37 +02:00
#endif
) {
method = p_method;
default_values = p_default_args;
#ifdef DEBUG_ENABLED
argument_names = p_arg_names;
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
method_name = p_method_name;
base_type = p_base_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 20:59:37 +02:00
#endif
}
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
template <class T, class R, class... P>
class InternalMethodRS : public Variant::InternalMethod {
public:
R(*method)
(T *, P...);
Vector<Variant> default_values;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
Vector<String> argument_names;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
virtual int get_argument_count() const {
return sizeof...(P);
}
virtual Variant::Type get_argument_type(int p_arg) const {
return call_get_argument_type<P...>(p_arg);
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-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
virtual String get_argument_name(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_names.size(), String());
return argument_names[p_arg];
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
virtual Vector<Variant> get_default_arguments() const {
return default_values;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual Variant::Type get_return_type() const {
return GetTypeInfo<R>::VARIANT_TYPE;
}
virtual uint32_t get_flags() const {
uint32_t f = 0;
if (get_return_type() == Variant::NIL) {
f |= FLAG_RETURNS_VARIANT;
}
return 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
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
const Variant **args = p_args;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
if ((size_t)p_argcount > sizeof...(P)) {
r_error.error = Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
r_error.argument = sizeof...(P);
return;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
if ((size_t)p_argcount < sizeof...(P)) {
size_t missing = sizeof...(P) - (size_t)p_argcount;
if (missing <= (size_t)default_values.size()) {
args = (const Variant **)alloca(sizeof...(P) * sizeof(const Variant *));
// GCC fails to see that `sizeof...(P)` cannot be 0 here given the previous
// conditions, so it raises a warning on the potential use of `i < 0` as the
// execution condition.
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
#endif
for (size_t i = 0; i < sizeof...(P); i++) {
if (i < (size_t)p_argcount) {
args[i] = p_args[i];
} else {
args[i] = &default_values[i - p_argcount + (default_values.size() - missing)];
}
}
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
} else {
#ifdef DEBUG_ENABLED
r_error.error = Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
r_error.argument = sizeof...(P);
#endif
return;
}
}
call_with_variant_args_retc_static_helper(VariantGetInternalPtr<T>::get_ptr(base), method, args, r_ret, r_error, BuildIndexSequence<sizeof...(P)>{});
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-10 02:10:30 +01: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 20:59:37 +02:00
virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
TypeAdjust<R>::adjust(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 20:59:37 +02:00
call_with_validated_variant_args_static_retc(base, method, p_args, r_ret);
}
#ifdef PTRCALL_ENABLED
virtual void ptrcall(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);
}
#endif
InternalMethodRS(R (*p_method)(T *, P...), const Vector<Variant> &p_default_args
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
,
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
const Vector<String> &p_arg_names, const StringName &p_method_name, Variant::Type p_base_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 20:59:37 +02:00
#endif
) {
method = p_method;
default_values = p_default_args;
#ifdef DEBUG_ENABLED
argument_names = p_arg_names;
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
method_name = p_method_name;
base_type = p_base_type;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
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
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
};
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
class InternalMethodVC : public Variant::InternalMethod {
public:
typedef void (*MethodVC)(Variant *, const Variant **, int, Variant &r_ret, Callable::CallError &);
MethodVC methodvc = nullptr;
uint32_t base_flags = 0;
Vector<String> argument_names;
Vector<Variant::Type> argument_types;
Variant::Type return_type = Variant::NIL;
virtual int get_argument_count() const {
return argument_names.size();
}
virtual Variant::Type get_argument_type(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_types.size(), Variant::NIL);
return argument_types[p_arg];
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
virtual String get_argument_name(int p_arg) const {
ERR_FAIL_INDEX_V(p_arg, argument_names.size(), String());
return argument_names[p_arg];
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
virtual Vector<Variant> get_default_arguments() const {
return Vector<Variant>();
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-10 02:10:30 +01: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 20:59:37 +02:00
virtual Variant::Type get_return_type() const {
return return_type;
}
virtual uint32_t get_flags() const {
return base_flags | FLAG_NO_PTRCALL;
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
virtual void call(Variant *base, const Variant **p_args, int p_argcount, Variant &r_ret, Callable::CallError &r_error) {
methodvc(base, p_args, p_argcount, r_ret, r_error);
Don't use to_utf8() and to_ascii() on empty String
2019-10-11 09:13:30 +02:00
}
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
virtual void validated_call(Variant *base, const Variant **p_args, Variant *r_ret) {
ERR_FAIL_MSG("No support for validated call");
}
#ifdef PTRCALL_ENABLED
virtual void ptrcall(void *p_base, const void **p_args, void *r_ret) {
ERR_FAIL_MSG("No support for ptrcall call");
}
#endif
InternalMethodVC(MethodVC p_method, uint32_t p_flags, const Vector<Variant::Type> &p_argument_types, const Variant::Type &p_return_type
#ifdef DEBUG_ENABLED
,
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
const Vector<String> &p_arg_names, const StringName &p_method_name, Variant::Type p_base_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 20:59:37 +02:00
#endif
) {
methodvc = p_method;
argument_types = p_argument_types;
return_type = p_return_type;
base_flags = p_flags;
#ifdef DEBUG_ENABLED
argument_names = p_arg_names;
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
method_name = p_method_name;
base_type = p_base_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 20:59:37 +02:00
#endif
}
};
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
typedef OAHashMap<StringName, Variant::InternalMethod *> MethodMap;
static MethodMap *type_internal_methods;
static List<StringName> *type_internal_method_names;
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
template <class T, class... P>
static void _bind_method(const StringName &p_name, void (T::*p_method)(P...), const Vector<Variant> &p_default_args = Vector<Variant>()
#ifdef DEBUG_ENABLED
,
const Vector<String> &p_argument_names = Vector<String>()
#endif
) {
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_MSG(p_argument_names.size() != sizeof...(P), "Wrong argument name count supplied for method: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
ERR_FAIL_COND(type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].has(p_name));
#endif
#ifdef DEBUG_ENABLED
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
Variant::InternalMethod *m = memnew((InternalMethod<T, P...>)(p_method, p_default_args, p_argument_names, p_name, 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 20:59:37 +02:00
#else
Variant::InternalMethod *m = memnew((InternalMethod<T, P...>)(p_method, p_default_args));
#endif
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].insert(p_name, m);
type_internal_method_names[GetTypeInfo<T>::VARIANT_TYPE].push_back(p_name);
Add String.to_utf8() and String.to_ascii()
2015-06-04 01:46:14 +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 20:59:37 +02:00
template <class T, class R, class... P>
static void _bind_method(const StringName &p_name, R (T::*p_method)(P...) const, const Vector<Variant> &p_default_args = Vector<Variant>()
#ifdef DEBUG_ENABLED
,
const Vector<String> &p_argument_names = Vector<String>()
#endif
) {
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_MSG(p_argument_names.size() != sizeof...(P), "Wrong argument name count supplied for method: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
ERR_FAIL_COND_MSG(type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].has(p_name), " Method already registered: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
#endif
#ifdef DEBUG_ENABLED
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
Variant::InternalMethod *m = memnew((InternalMethodRC<T, R, P...>)(p_method, p_default_args, p_argument_names, p_name, 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 20:59:37 +02:00
#else
Variant::InternalMethod *m = memnew((InternalMethodRC<T, R, P...>)(p_method, p_default_args));
#endif
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].insert(p_name, m);
type_internal_method_names[GetTypeInfo<T>::VARIANT_TYPE].push_back(p_name);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
template <class T, class R, class... P>
static void _bind_method(const StringName &p_name, R (T::*p_method)(P...), const Vector<Variant> &p_default_args = Vector<Variant>()
#ifdef DEBUG_ENABLED
,
const Vector<String> &p_argument_names = Vector<String>()
#endif
) {
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_MSG(p_argument_names.size() != sizeof...(P), "Wrong argument name count supplied for method: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
ERR_FAIL_COND_MSG(type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].has(p_name), " Method already registered: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
#endif
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
#ifdef DEBUG_ENABLED
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
Variant::InternalMethod *m = memnew((InternalMethodR<T, R, P...>)(p_method, p_default_args, p_argument_names, p_name, 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 20:59:37 +02:00
#else
Variant::InternalMethod *m = memnew((InternalMethodR<T, R, P...>)(p_method, p_default_args));
#endif
type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].insert(p_name, m);
type_internal_method_names[GetTypeInfo<T>::VARIANT_TYPE].push_back(p_name);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
#ifdef DEBUG_ENABLED
#define bind_method(m_type, m_method, m_arg_names, m_default_args) _VariantCall::_bind_method(#m_method, &m_type ::m_method, m_default_args, m_arg_names)
#else
#define bind_method(m_type, m_method, m_arg_names, m_default_args) _VariantCall::_bind_method(#m_method, &m_type ::m_method, m_default_args)
#endif
#ifdef DEBUG_ENABLED
#define bind_methodv(m_name, m_method, m_arg_names, m_default_args) _VariantCall::_bind_method(#m_name, m_method, m_default_args, m_arg_names)
#else
#define bind_methodv(m_name, m_method, m_arg_names, m_default_args) _VariantCall::_bind_method(#m_name, m_method, m_default_args)
#endif
template <class T, class R, class... P>
static void _bind_function(const StringName &p_name, R (*p_method)(T *, P...), const Vector<Variant> &p_default_args = Vector<Variant>()
#ifdef DEBUG_ENABLED
,
const Vector<String> &p_argument_names = Vector<String>()
#endif
) {
#ifdef DEBUG_ENABLED
ERR_FAIL_COND_MSG(p_argument_names.size() != sizeof...(P), "Wrong argument name count supplied for method: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
ERR_FAIL_COND_MSG(type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].has(p_name), " Method already registered: " + Variant::get_type_name(GetTypeInfo<T>::VARIANT_TYPE) + "::" + String(p_name));
#endif
#ifdef DEBUG_ENABLED
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
Variant::InternalMethod *m = memnew((InternalMethodRS<T, R, P...>)(p_method, p_default_args, p_argument_names, p_name, 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 20:59:37 +02:00
#else
Variant::InternalMethod *m = memnew((InternalMethodRS<T, R, P...>)(p_method, p_default_args));
#endif
type_internal_methods[GetTypeInfo<T>::VARIANT_TYPE].insert(p_name, m);
type_internal_method_names[GetTypeInfo<T>::VARIANT_TYPE].push_back(p_name);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
#ifdef DEBUG_ENABLED
#define bind_function(m_name, m_method, m_arg_names, m_default_args) _VariantCall::_bind_function(m_name, m_method, m_default_args, m_arg_names)
#else
#define bind_function(m_name, m_method, m_arg_names, m_default_args) _VariantCall::_bind_function(m_name, m_method, m_default_args)
#endif
static void _bind_custom(Variant::Type p_type, const StringName &p_name, InternalMethodVC::MethodVC p_method, uint32_t p_flags, const Vector<Variant::Type> &p_argument_types, const Variant::Type &p_return_type
#ifdef DEBUG_ENABLED
,
const Vector<String> &p_argument_names = Vector<String>()
#endif
) {
#ifdef DEBUG_ENABLED
Add name and base type to Variant::InternalMethod (on debug) This is useful to showing error messages when a pointer to an InternalMethod is the only information available.
2020-10-22 13:36:15 +02:00
Variant::InternalMethod *m = memnew(InternalMethodVC(p_method, p_flags, p_argument_types, p_return_type, p_argument_names, p_name, p_type));
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
#else
Variant::InternalMethod *m = memnew(InternalMethodVC(p_method, p_flags, p_argument_types, p_return_type));
#endif
type_internal_methods[p_type].insert(p_name, m);
type_internal_method_names[p_type].push_back(p_name);
}
#ifdef DEBUG_ENABLED
#define bind_custom(m_type, m_name, m_method, m_flags, m_arg_types, m_ret_type, m_arg_names) _VariantCall::_bind_custom(m_type, m_name, m_method, m_flags, m_arg_types, m_ret_type, m_arg_names)
#else
#define bind_custom(m_type, m_name, m_method, m_flags, m_arg_types, m_ret_type, m_arg_names) _VariantCall::_bind_custom(m_type, m_name, m_method, m_flags, m_arg_types, m_ret_type)
#endif
static String func_PackedByteArray_get_string_from_ascii(PackedByteArray *p_instance) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
CharString cs;
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
cs.resize(p_instance->size() + 1);
copymem(cs.ptrw(), r, p_instance->size());
cs[p_instance->size()] = 0;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
return s;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
static String func_PackedByteArray_get_string_from_utf8(PackedByteArray *p_instance) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
s.parse_utf8((const char *)r, p_instance->size());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
return s;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02: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 12:43:20 +02: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 20:59:37 +02:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
s.parse_utf16((const char16_t *)r, p_instance->size() / 2);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
return s;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02: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 12:43:20 +02: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 20:59:37 +02:00
if (p_instance->size() > 0) {
const uint8_t *r = p_instance->ptr();
s = String((const char32_t *)r, p_instance->size() / 4);
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02:00
return s;
[Complex Test Layouts] Change `String` to use UTF-32 encoding on all platforms.
2020-07-27 12:43:20 +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 20:59:37 +02: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 22:06:54 +01:00
PackedByteArray compressed;
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +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 20:59:37 +02: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));
int result = Compression::compress(compressed.ptrw(), p_instance->ptr(), p_instance->size(), mode);
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +02: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 21:52:54 +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 20:59:37 +02:00
return compressed;
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +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 20:59:37 +02: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 22:06:54 +01: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 20:59:37 +02:00
Compression::Mode mode = (Compression::Mode)(p_mode);
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +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 20:59:37 +02:00
int64_t buffer_size = p_buffer_size;
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +02: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 20:59:37 +02:00
ERR_FAIL_V_MSG(decompressed, "Decompression buffer size must be greater than zero.");
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +02:00
}
decompressed.resize(buffer_size);
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
int result = Compression::decompress(decompressed.ptrw(), buffer_size, p_instance->ptr(), p_instance->size(), mode);
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +02: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 20:59:37 +02:00
return decompressed;
Add basic compression functions to PoolBaseArray
2017-06-19 07:46:29 +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 20:59:37 +02: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 10:05:32 +02: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 20:59:37 +02: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 10:05:32 +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 20:59:37 +02: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 10:05:32 +02: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 20:59:37 +02: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 10:05:32 +02: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 20:59:37 +02: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 10:05:32 +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 20:59:37 +02:00
static String func_PackedByteArray_hex_encode(PackedByteArray *p_instance) {
if (p_instance->size() == 0) {
return String();
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02: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-10 02:10:30 +01: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 20:59:37 +02: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);
callable->call(p_args, p_argcount, r_ret, r_error);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02: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);
callable->call_deferred(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 05:10:51 +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 20:59:37 +02: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);
r_ret = callable->bind(p_args, p_argcount);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02: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-10 02:10:30 +01:00
}
struct ConstantData {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Map<StringName, int> 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 21:57:17 +02:00
#ifdef DEBUG_ENABLED
List<StringName> value_ordered;
#endif
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
Map<StringName, Variant> variant_value;
Docs: Fix order of variant constants.
2020-05-20 15:45:42 +02:00
#ifdef DEBUG_ENABLED
List<StringName> variant_value_ordered;
#endif
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
static ConstantData *constant_data;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:57:17 +02:00
static void add_constant(int p_type, StringName p_constant_name, int p_constant_value) {
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);
#endif
}
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
static void add_variant_constant(int p_type, StringName p_constant_name, const Variant &p_constant_value) {
constant_data[p_type].variant_value[p_constant_name] = p_constant_value;
Docs: Fix order of variant constants.
2020-05-20 15:45:42 +02:00
#ifdef DEBUG_ENABLED
constant_data[p_type].variant_value_ordered.push_back(p_constant_name);
#endif
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
};
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
_VariantCall::ConstantData *_VariantCall::constant_data = nullptr;
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
_VariantCall::MethodMap *_VariantCall::type_internal_methods = nullptr;
List<StringName> *_VariantCall::type_internal_method_names = nullptr;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
Variant Variant::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
Variant ret;
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
call_ptr(p_method, p_args, p_argcount, &ret, r_error);
Property reporty base type when a function fails, fixes #4581 probably also closes other issues
2016-06-20 06:15:02 +02:00
return ret;
}
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
void Variant::call_ptr(const StringName &p_method, const Variant **p_args, int p_argcount, Variant *r_ret, Callable::CallError &r_error) {
Property reporty base type when a function fails, fixes #4581 probably also closes other issues
2016-06-20 06:15:02 +02:00
Variant ret;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
if (type == Variant::OBJECT) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
//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 20:27:19 +01: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 06:15:02 +02:00
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
#ifdef DEBUG_ENABLED
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
if (EngineDebugger::is_active() && !_get_obj().id.is_reference() && 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 20:27:19 +01: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 20:03:10 +01:00
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
#endif
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ret = _get_obj().obj->call(p_method, p_args, p_argcount, r_error);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
//else if (type==Variant::METHOD) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
} else {
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
r_error.error = Callable::CallError::CALL_OK;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
Variant::InternalMethod **m = _VariantCall::type_internal_methods[type].lookup_ptr(p_method);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01: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 20:59:37 +02:00
if (m) {
(*m)->call((Variant *)this, p_args, p_argcount, ret, r_error);
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
} else {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
//ok fail because not found
r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
return;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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_error.error == Callable::CallError::CALL_OK && r_ret) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*r_ret = ret;
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-10 02:10:30 +01:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
#define VCALL(m_type, m_method) _VariantCall::_call_##m_type##_##m_method
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01: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 20:03:10 +01: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-20 02:01:41 +02: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 20:03:10 +01: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-20 02:01:41 +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 20:59:37 +02:00
return _VariantCall::type_internal_methods[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-20 02:01:41 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Vector<Variant::Type> Variant::get_method_argument_types(Variant::Type p_type, const StringName &p_method) {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Vector<Variant::Type> types;
More progress on visual script editing
2016-08-03 16:28:20 +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 20:59:37 +02:00
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method);
if (*m) {
types.resize((*m)->get_argument_count());
for (int i = 0; i < (*m)->get_argument_count(); i++) {
types.write[i] = (*m)->get_argument_type(i);
}
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
}
More progress on visual script editing
2016-08-03 16:28:20 +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 20:59:37 +02:00
return types;
More progress on visual script editing
2016-08-03 16:28:20 +02:00
}
Fixed constness of variant functions, as well as visual script sequence ports. Closes #11258
2017-09-25 22:08:48 +02:00
bool Variant::is_method_const(Variant::Type p_type, const StringName &p_method) {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method);
if (*m) {
return (*m)->get_flags() & Variant::InternalMethod::FLAG_IS_CONST;
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
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
return false;
Fixed constness of variant functions, as well as visual script sequence ports. Closes #11258
2017-09-25 22:08:48 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Vector<StringName> Variant::get_method_argument_names(Variant::Type p_type, const StringName &p_method) {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Vector<StringName> argnames;
More progress on visual script editing
2016-08-03 16:28:20 +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 20:59:37 +02:00
#ifdef DEBUG_ENABLED
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method);
if (*m) {
argnames.resize((*m)->get_argument_count());
for (int i = 0; i < (*m)->get_argument_count(); i++) {
argnames.write[i] = (*m)->get_argument_name(i);
}
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
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
#endif
return argnames;
More progress on visual script editing
2016-08-03 16:28:20 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Variant::Type Variant::get_method_return_type(Variant::Type p_type, const StringName &p_method, bool *r_has_return) {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Variant::Type rt = Variant::NIL;
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method);
if (*m) {
rt = (*m)->get_return_type();
if (r_has_return) {
*r_has_return = ((*m)->get_flags() & Variant::InternalMethod::FLAG_RETURNS_VARIANT) || rt != Variant::NIL;
}
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
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
return rt;
More progress on visual script editing
2016-08-03 16:28:20 +02:00
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Vector<Variant> Variant::get_method_default_arguments(Variant::Type p_type, const StringName &p_method) {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method);
if (*m) {
return (*m)->get_default_arguments();
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
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
return Vector<Variant>();
More progress on visual script editing
2016-08-03 16:28:20 +02:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
void Variant::get_method_list(List<MethodInfo> *p_list) const {
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
for (List<StringName>::Element *E = _VariantCall::type_internal_method_names[type].front(); E; E = E->next()) {
Variant::InternalMethod **m = _VariantCall::type_internal_methods[type].lookup_ptr(E->get());
ERR_CONTINUE(!*m);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
MethodInfo mi;
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
mi.name = E->get();
mi.return_val.type = (*m)->get_return_type();
if ((*m)->get_flags() & Variant::InternalMethod::FLAG_RETURNS_VARIANT) {
mi.return_val.usage |= PROPERTY_USAGE_NIL_IS_VARIANT;
}
if ((*m)->get_flags() & Variant::InternalMethod::FLAG_IS_CONST) {
Fixed constness of variant functions, as well as visual script sequence ports. Closes #11258
2017-09-25 22:08:48 +02:00
mi.flags |= METHOD_FLAG_CONST;
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
if ((*m)->get_flags() & Variant::InternalMethod::FLAG_VARARGS) {
mi.flags |= METHOD_FLAG_VARARG;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
for (int i = 0; i < (*m)->get_argument_count(); i++) {
PropertyInfo arg;
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
#ifdef 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 20:59:37 +02:00
arg.name = (*m)->get_argument_name(i);
#else
arg.name = "arg" + itos(i + 1);
added floor() and ceil() to Vector3
2015-07-15 01:59:35 +02:00
#endif
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
arg.type = (*m)->get_argument_type(i);
mi.arguments.push_back(arg);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
mi.default_arguments = (*m)->get_default_arguments();
Reworked signal connection system, added support for Callable and Signal objects and made them default.
2020-02-19 20:27:19 +01:00
p_list->push_back(mi);
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ERR_FAIL_INDEX(p_type, Variant::VARIANT_MAX);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 21:57:17 +02:00
#ifdef DEBUG_ENABLED
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (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 21:57:17 +02:00
p_constants->push_back(E->get());
#else
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
for (Map<StringName, int>::Element *E = cd.value.front(); E; E = E->next()) {
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
p_constants->push_back(E->key());
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 21:57:17 +02:00
#endif
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 15:45:42 +02:00
#ifdef DEBUG_ENABLED
for (List<StringName>::Element *E = cd.variant_value_ordered.front(); E; E = E->next()) {
p_constants->push_back(E->get());
#else
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
for (Map<StringName, Variant>::Element *E = cd.variant_value.front(); E; E = E->next()) {
p_constants->push_back(E->key());
Docs: Fix order of variant constants.
2020-05-20 15:45:42 +02:00
#endif
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
}
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
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-10 02:10:30 +01: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*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-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
ERR_FAIL_INDEX_V(p_type, Variant::VARIANT_MAX, 0);
_VariantCall::ConstantData &cd = _VariantCall::constant_data[p_type];
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
Map<StringName, int>::Element *E = cd.value.find(p_value);
Basic type constants for visual script
2016-09-02 07:13:12 +02:00
if (!E) {
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
Map<StringName, Variant>::Element *F = cd.variant_value.find(p_value);
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
}
Add -Wshadow=local to warnings and fix reported issues. Fixes #25316.
2019-02-12 21:10:08 +01:00
return F->get();
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 07:13:12 +02: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) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
*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 07:13:12 +02:00
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
return E->get();
}
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
Variant::InternalMethod *Variant::get_internal_method(Type p_type, const StringName &p_method_name) {
ERR_FAIL_INDEX_V(p_type, VARIANT_MAX, nullptr);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 20:59:37 +02:00
Variant::InternalMethod **m = _VariantCall::type_internal_methods[p_type].lookup_ptr(p_method_name);
if (*m) {
return *m;
}
return nullptr;
}
Refactored variant constructor logic
2020-11-09 04:19:09 +01:00
void Variant::_register_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 20:59:37 +02:00
_VariantCall::type_internal_methods = memnew_arr(_VariantCall::MethodMap, Variant::VARIANT_MAX);
_VariantCall::type_internal_method_names = memnew_arr(List<StringName>, Variant::VARIANT_MAX);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
_VariantCall::constant_data = memnew_arr(_VariantCall::ConstantData, Variant::VARIANT_MAX);
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 20:59:37 +02:00
bind_method(String, casecmp_to, sarray("to"), varray());
bind_method(String, nocasecmp_to, sarray("to"), varray());
bind_method(String, naturalnocasecmp_to, sarray("to"), varray());
bind_method(String, length, sarray(), varray());
bind_method(String, substr, sarray("from", "len"), varray(-1));
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(find, static_cast<int (String::*)(const String &, int) const>(&String::find), sarray("what", "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 20:59:37 +02:00
bind_method(String, count, sarray("what", "from", "to"), varray(0, 0));
bind_method(String, countn, sarray("what", "from", "to"), varray(0, 0));
bind_method(String, findn, sarray("what", "from"), varray(0));
bind_method(String, rfind, sarray("what", "from"), varray(-1));
bind_method(String, rfindn, sarray("what", "from"), varray(-1));
bind_method(String, match, sarray("expr"), varray());
bind_method(String, matchn, sarray("expr"), varray());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(begins_with, static_cast<bool (String::*)(const String &) const>(&String::begins_with), sarray("text"), 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 20:59:37 +02:00
bind_method(String, ends_with, sarray("text"), varray());
bind_method(String, is_subsequence_of, sarray("text"), varray());
bind_method(String, is_subsequence_ofi, sarray("text"), varray());
bind_method(String, bigrams, sarray(), varray());
bind_method(String, similarity, sarray("text"), varray());
bind_method(String, format, sarray("values", "placeholder"), varray("{_}"));
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(replace, static_cast<String (String::*)(const String &, const String &) const>(&String::replace), sarray("what", "forwhat"), 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 20:59:37 +02:00
bind_method(String, replacen, sarray("what", "forwhat"), varray());
bind_method(String, repeat, sarray("count"), varray());
bind_method(String, insert, sarray("position", "what"), varray());
bind_method(String, capitalize, sarray(), varray());
bind_method(String, split, sarray("delimiter", "allow_empty", "maxsplit"), varray(true, 0));
bind_method(String, rsplit, sarray("delimiter", "allow_empty", "maxsplit"), varray(true, 0));
bind_method(String, split_floats, sarray("delimiter", "allow_empty"), varray(true));
bind_method(String, join, sarray("parts"), varray());
bind_method(String, to_upper, sarray(), varray());
bind_method(String, to_lower, sarray(), varray());
bind_method(String, left, sarray("position"), varray());
bind_method(String, right, sarray("position"), varray());
bind_method(String, strip_edges, sarray("left", "right"), varray(true, true));
bind_method(String, strip_escapes, sarray(), varray());
bind_method(String, lstrip, sarray("chars"), varray());
bind_method(String, rstrip, sarray("chars"), varray());
bind_method(String, get_extension, sarray(), varray());
bind_method(String, get_basename, sarray(), varray());
bind_method(String, plus_file, sarray("file"), varray());
bind_method(String, ord_at, sarray("at"), varray());
bind_method(String, dedent, 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
// FIXME: String needs to be immutable when binding
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
//bind_method(String, erase, sarray("position", "chars"), varray());
bind_method(String, hash, sarray(), varray());
bind_method(String, md5_text, sarray(), varray());
bind_method(String, sha1_text, sarray(), varray());
bind_method(String, sha256_text, sarray(), varray());
bind_method(String, md5_buffer, sarray(), varray());
bind_method(String, sha1_buffer, sarray(), varray());
bind_method(String, sha256_buffer, sarray(), varray());
bind_method(String, empty, 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
// FIXME: Static function, not sure how to bind
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
//bind_method(String, humanize_size, sarray("size"), varray());
bind_method(String, is_abs_path, sarray(), varray());
bind_method(String, is_rel_path, sarray(), varray());
bind_method(String, get_base_dir, sarray(), varray());
bind_method(String, get_file, sarray(), varray());
bind_method(String, xml_escape, sarray("escape_quotes"), varray(false));
bind_method(String, xml_unescape, sarray(), varray());
bind_method(String, http_escape, sarray(), varray());
bind_method(String, http_unescape, sarray(), varray());
bind_method(String, c_escape, sarray(), varray());
bind_method(String, c_unescape, sarray(), varray());
bind_method(String, json_escape, sarray(), varray());
bind_method(String, percent_encode, sarray(), varray());
bind_method(String, percent_decode, sarray(), varray());
bind_method(String, is_valid_identifier, sarray(), varray());
bind_method(String, is_valid_integer, sarray(), varray());
bind_method(String, is_valid_float, sarray(), varray());
bind_method(String, is_valid_hex_number, sarray("with_prefix"), varray(false));
bind_method(String, is_valid_html_color, sarray(), varray());
bind_method(String, is_valid_ip_address, sarray(), varray());
bind_method(String, is_valid_filename, sarray(), varray());
bind_method(String, to_int, sarray(), varray());
bind_method(String, to_float, sarray(), varray());
bind_method(String, hex_to_int, sarray("with_prefix"), varray(true));
bind_method(String, bin_to_int, sarray("with_prefix"), varray(true));
bind_method(String, lpad, sarray("min_length", "character"), varray(" "));
bind_method(String, rpad, sarray("min_length", "character"), varray(" "));
bind_method(String, pad_decimals, sarray("digits"), varray());
bind_method(String, pad_zeros, sarray("digits"), varray());
bind_method(String, trim_prefix, sarray("prefix"), varray());
bind_method(String, trim_suffix, sarray("suffix"), varray());
bind_method(String, to_ascii_buffer, sarray(), varray());
bind_method(String, to_utf8_buffer, sarray(), varray());
bind_method(String, to_utf16_buffer, sarray(), varray());
bind_method(String, to_utf32_buffer, 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
/* 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 20:59:37 +02:00
bind_method(Vector2, angle, sarray(), varray());
bind_method(Vector2, angle_to, sarray("to"), varray());
bind_method(Vector2, angle_to_point, sarray("to"), varray());
bind_method(Vector2, direction_to, sarray("b"), varray());
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());
bind_method(Vector2, normalized, sarray(), varray());
bind_method(Vector2, is_normalized, sarray(), varray());
bind_method(Vector2, is_equal_approx, sarray("to"), varray());
bind_method(Vector2, posmod, sarray("mod"), varray());
bind_method(Vector2, posmodv, sarray("modv"), varray());
bind_method(Vector2, project, sarray("b"), varray());
bind_method(Vector2, lerp, sarray("with", "t"), varray());
bind_method(Vector2, slerp, sarray("with", "t"), varray());
bind_method(Vector2, cubic_interpolate, sarray("b", "pre_a", "post_b", "t"), varray());
bind_method(Vector2, move_toward, sarray("to", "delta"), varray());
bind_method(Vector2, rotated, sarray("phi"), varray());
bind_method(Vector2, tangent, sarray(), varray());
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());
bind_method(Vector2, reflect, sarray("n"), varray());
bind_method(Vector2, cross, sarray("with"), varray());
bind_method(Vector2, abs, sarray(), varray());
bind_method(Vector2, sign, 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(Vector2, snapped, sarray("by"), 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 20:59:37 +02:00
bind_method(Vector2, clamped, sarray("length"), 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 20:59:37 +02:00
bind_method(Vector2i, aspect, sarray(), varray());
bind_method(Vector2i, sign, sarray(), varray());
bind_method(Vector2i, abs, 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
/* 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 20:59:37 +02:00
bind_method(Rect2, get_area, sarray(), varray());
bind_method(Rect2, has_no_area, sarray(), varray());
bind_method(Rect2, has_point, sarray("point"), varray());
bind_method(Rect2, is_equal_approx, sarray("rect"), varray());
bind_method(Rect2, intersects, sarray("b", "include_borders"), varray(false));
bind_method(Rect2, encloses, sarray("b"), varray());
bind_method(Rect2, clip, sarray("b"), varray());
bind_method(Rect2, merge, sarray("b"), varray());
bind_method(Rect2, expand, sarray("to"), varray());
bind_method(Rect2, grow, sarray("by"), varray());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(grow_margin, &Rect2::grow_margin_bind, sarray("margin", "by"), 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 20:59:37 +02:00
bind_method(Rect2, grow_individual, sarray("left", "top", "right", "bottom"), varray());
bind_method(Rect2, abs, sarray(), varray());
/* Rect2i */
bind_method(Rect2i, get_area, sarray(), varray());
bind_method(Rect2i, has_no_area, sarray(), varray());
bind_method(Rect2i, has_point, sarray("point"), varray());
bind_method(Rect2i, intersects, sarray("b"), varray());
bind_method(Rect2i, encloses, sarray("b"), varray());
bind_method(Rect2i, clip, sarray("b"), varray());
bind_method(Rect2i, merge, sarray("b"), varray());
bind_method(Rect2i, expand, sarray("to"), varray());
bind_method(Rect2i, grow, sarray("by"), varray());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(grow_margin, &Rect2i::grow_margin_bind, sarray("margin", "by"), 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 20:59:37 +02:00
bind_method(Rect2i, grow_individual, sarray("left", "top", "right", "bottom"), varray());
bind_method(Rect2i, abs, sarray(), varray());
/* Vector3 */
bind_method(Vector3, min_axis, sarray(), varray());
bind_method(Vector3, max_axis, sarray(), varray());
bind_method(Vector3, angle_to, sarray("to"), varray());
bind_method(Vector3, direction_to, sarray("b"), varray());
bind_method(Vector3, distance_to, sarray("b"), varray());
bind_method(Vector3, distance_squared_to, sarray("b"), varray());
bind_method(Vector3, length, sarray(), varray());
bind_method(Vector3, length_squared, sarray(), varray());
bind_method(Vector3, normalized, sarray(), varray());
bind_method(Vector3, is_normalized, sarray(), varray());
bind_method(Vector3, is_equal_approx, sarray("to"), varray());
bind_method(Vector3, inverse, sarray(), varray());
bind_method(Vector3, snapped, sarray("by"), varray());
bind_method(Vector3, rotated, sarray("by_axis", "phi"), varray());
bind_method(Vector3, lerp, sarray("b", "t"), varray());
bind_method(Vector3, slerp, sarray("b", "t"), varray());
bind_method(Vector3, cubic_interpolate, sarray("b", "pre_a", "post_b", "t"), varray());
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, to_diagonal_matrix, sarray(), 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());
bind_method(Vector3, reflect, sarray("n"), varray());
bind_method(Vector3, sign, sarray(), varray());
/* Vector3i */
bind_method(Vector3i, min_axis, sarray(), varray());
bind_method(Vector3i, max_axis, sarray(), varray());
bind_method(Vector3i, sign, sarray(), varray());
bind_method(Vector3i, abs, sarray(), varray());
/* Plane */
bind_method(Plane, normalized, sarray(), varray());
bind_method(Plane, center, sarray(), varray());
bind_method(Plane, is_equal_approx, sarray("to_plane"), varray());
bind_method(Plane, is_point_over, sarray("plane"), varray());
bind_method(Plane, distance_to, sarray("point"), varray());
bind_method(Plane, has_point, sarray("point", "epsilon"), varray(CMP_EPSILON));
bind_method(Plane, project, sarray("point"), varray());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(intersect_3, &Plane::intersect_3_bind, sarray("b", "c"), varray());
bind_methodv(intersects_ray, &Plane::intersects_ray_bind, sarray("from", "dir"), varray());
bind_methodv(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 20:59:37 +02: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
/* Quat */
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
bind_method(Quat, length, sarray(), varray());
bind_method(Quat, length_squared, sarray(), varray());
bind_method(Quat, normalized, sarray(), varray());
bind_method(Quat, is_normalized, sarray(), varray());
bind_method(Quat, is_equal_approx, sarray("to"), varray());
bind_method(Quat, inverse, sarray(), varray());
bind_method(Quat, dot, sarray("with"), varray());
bind_method(Quat, slerp, sarray("b", "t"), varray());
bind_method(Quat, slerpni, sarray("b", "t"), varray());
bind_method(Quat, cubic_slerp, sarray("b", "pre_a", "post_b", "t"), varray());
bind_method(Quat, get_euler, 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
// FIXME: Quat is atomic, this should be done via construcror
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
//ADDFUNC1(QUAT, NIL, Quat, set_euler, VECTOR3, "euler", varray());
//ADDFUNC2(QUAT, NIL, Quat, set_axis_angle, VECTOR3, "axis", FLOAT, "angle", varray());
/* 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());
bind_method(Color, inverted, sarray(), varray());
bind_method(Color, lerp, sarray("b", "t"), varray());
bind_method(Color, lightened, sarray("amount"), varray());
bind_method(Color, darkened, sarray("amount"), varray());
bind_method(Color, to_html, sarray("with_alpha"), varray(true));
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
bind_method(Color, blend, sarray("over"), 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 20:59:37 +02: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
// FIXME: Color is immutable, need to probably find a way to do this via constructor
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
//ADDFUNC4R(COLOR, COLOR, Color, from_hsv, FLOAT, "h", FLOAT, "s", FLOAT, "v", FLOAT, "a", varray(1.0));
bind_method(Color, is_equal_approx, sarray("to"), varray());
/* RID */
Variant: Rename Type::_RID to Type::RID The underscore prefix was used to avoid the conflict between the `RID` class name and the matching enum value in `Variant::Type`. This can be fixed differently by prefixing uses of the `RID` class in `Variant` with the scope resolution operator, as done already for `AABB`.
2020-11-09 14:53:05 +01:00
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 20:59:37 +02: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());
bind_method(NodePath, get_subname, sarray("idx"), varray());
bind_method(NodePath, get_concatenated_subnames, sarray(), varray());
bind_method(NodePath, get_as_property_path, sarray(), varray());
bind_method(NodePath, is_empty, sarray(), varray());
/* Callable */
bind_method(Callable, is_null, sarray(), varray());
bind_method(Callable, is_custom, sarray(), varray());
bind_method(Callable, is_standard, sarray(), varray());
bind_method(Callable, get_object, sarray(), varray());
bind_method(Callable, get_object_id, sarray(), varray());
bind_method(Callable, get_method, sarray(), varray());
bind_method(Callable, hash, sarray(), varray());
bind_method(Callable, unbind, sarray("argcount"), varray());
bind_custom(Variant::CALLABLE, "call", _VariantCall::func_Callable_call, Variant::InternalMethod::FLAG_VARARGS | Variant::InternalMethod::FLAG_RETURNS_VARIANT, Vector<Variant::Type>(), Variant::NIL, sarray());
bind_custom(Variant::CALLABLE, "call_deferred", _VariantCall::func_Callable_call_deferred, Variant::InternalMethod::FLAG_VARARGS, Vector<Variant::Type>(), Variant::NIL, sarray());
bind_custom(Variant::CALLABLE, "bind", _VariantCall::func_Callable_bind, Variant::InternalMethod::FLAG_VARARGS, Vector<Variant::Type>(), Variant::CALLABLE, sarray());
/* 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());
bind_method(Signal, connect, sarray("callable", "binds", "flags"), varray(Array(), 0));
bind_method(Signal, disconnect, sarray("callable"), varray());
bind_method(Signal, is_connected, sarray("callable"), varray());
bind_method(Signal, get_connections, sarray(), varray());
bind_custom(Variant::SIGNAL, "emit", _VariantCall::func_Signal_emit, Variant::InternalMethod::FLAG_VARARGS, Vector<Variant::Type>(), Variant::NIL, sarray());
/* 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());
bind_method(Transform2D, orthonormalized, sarray(), varray());
bind_method(Transform2D, rotated, sarray("phi"), varray());
bind_method(Transform2D, scaled, sarray("scale"), varray());
bind_method(Transform2D, translated, sarray("offset"), varray());
bind_method(Transform2D, basis_xform, sarray("v"), varray());
bind_method(Transform2D, basis_xform_inv, sarray("v"), varray());
bind_method(Transform2D, interpolate_with, sarray("xform", "t"), varray());
bind_method(Transform2D, is_equal_approx, sarray("xform"), varray());
/* 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());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(rotated, static_cast<Basis (Basis::*)(const Vector3 &, float) const>(&Basis::rotated), sarray("axis", "phi"), 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 20:59:37 +02:00
bind_method(Basis, scaled, sarray("scale"), varray());
bind_method(Basis, get_scale, sarray(), varray());
bind_method(Basis, get_euler, sarray(), varray());
bind_method(Basis, tdotx, sarray("with"), varray());
bind_method(Basis, tdoty, sarray("with"), varray());
bind_method(Basis, tdotz, sarray("with"), varray());
bind_method(Basis, get_orthogonal_index, sarray(), varray());
bind_method(Basis, slerp, sarray("b", "t"), varray());
bind_method(Basis, is_equal_approx, sarray("b"), varray());
bind_method(Basis, get_rotation_quat, sarray(), varray());
/* AABB */
bind_method(::AABB, abs, sarray(), varray());
bind_method(::AABB, get_area, sarray(), varray());
bind_method(::AABB, has_no_area, sarray(), varray());
bind_method(::AABB, has_no_surface, sarray(), varray());
bind_method(::AABB, has_point, sarray("point"), varray());
bind_method(::AABB, is_equal_approx, sarray("aabb"), varray());
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());
bind_method(::AABB, get_support, sarray("dir"), varray());
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());
Fix invalid method names
2020-10-22 19:50:25 +02:00
bind_methodv(intersects_segment, &AABB::intersects_segment_bind, sarray("from", "to"), varray());
bind_methodv(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 20:59:37 +02:00
/* Transform */
bind_method(Transform, inverse, sarray(), varray());
bind_method(Transform, affine_inverse, sarray(), varray());
bind_method(Transform, orthonormalized, sarray(), varray());
bind_method(Transform, rotated, sarray("axis", "phi"), varray());
bind_method(Transform, scaled, sarray("scale"), varray());
bind_method(Transform, translated, sarray("offset"), varray());
bind_method(Transform, looking_at, sarray("target", "up"), varray());
bind_method(Transform, interpolate_with, sarray("xform", "weight"), varray());
bind_method(Transform, is_equal_approx, sarray("xform"), varray());
/* Dictionary */
bind_method(Dictionary, size, sarray(), varray());
bind_method(Dictionary, empty, sarray(), varray());
bind_method(Dictionary, clear, sarray(), varray());
bind_method(Dictionary, has, sarray("key"), varray());
bind_method(Dictionary, has_all, sarray("keys"), varray());
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 17:29:59 +02:00
bind_method(Dictionary, duplicate, sarray("deep"), 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 20:59:37 +02:00
bind_method(Dictionary, get, sarray("key", "default"), varray(Variant()));
/* Array */
bind_method(Array, size, sarray(), varray());
bind_method(Array, empty, sarray(), varray());
bind_method(Array, clear, sarray(), varray());
bind_method(Array, hash, sarray(), varray());
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 20:59:37 +02:00
bind_method(Array, resize, sarray("size"), varray());
bind_method(Array, insert, sarray("position", "value"), varray());
bind_method(Array, remove, sarray("position"), varray());
bind_method(Array, erase, sarray("value"), varray());
bind_method(Array, front, sarray(), varray());
bind_method(Array, back, sarray(), varray());
bind_method(Array, find, sarray("what", "from"), varray(0));
bind_method(Array, rfind, sarray("what", "from"), varray(-1));
bind_method(Array, find_last, sarray("value"), varray());
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());
bind_method(Array, sort, sarray(), varray());
bind_method(Array, sort_custom, sarray("obj", "func"), varray());
bind_method(Array, shuffle, sarray(), varray());
bind_method(Array, bsearch, sarray("value", "before"), varray(true));
bind_method(Array, bsearch_custom, sarray("value", "obj", "func", "before"), varray(true));
bind_method(Array, invert, sarray(), varray());
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
bind_method(Array, duplicate, sarray("deep"), 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 20:59:37 +02:00
bind_method(Array, slice, sarray("begin", "end", "step", "deep"), varray(1, false));
bind_method(Array, max, sarray(), varray());
bind_method(Array, min, sarray(), varray());
/* Byte Array */
bind_method(PackedByteArray, size, sarray(), varray());
bind_method(PackedByteArray, empty, sarray(), varray());
bind_method(PackedByteArray, set, sarray("index", "value"), varray());
bind_method(PackedByteArray, push_back, sarray("value"), varray());
bind_method(PackedByteArray, append, sarray("value"), varray());
bind_method(PackedByteArray, append_array, sarray("array"), varray());
bind_method(PackedByteArray, remove, sarray("index"), varray());
bind_method(PackedByteArray, insert, sarray("at_index", "value"), varray());
bind_method(PackedByteArray, resize, sarray("new_size"), varray());
bind_method(PackedByteArray, has, sarray("value"), varray());
bind_method(PackedByteArray, invert, sarray(), varray());
bind_method(PackedByteArray, subarray, sarray("from", "to"), varray());
bind_method(PackedByteArray, sort, sarray(), varray());
bind_function("get_string_from_ascii", _VariantCall::func_PackedByteArray_get_string_from_ascii, sarray(), varray());
bind_function("get_string_from_utf8", _VariantCall::func_PackedByteArray_get_string_from_utf8, sarray(), varray());
bind_function("get_string_from_utf16", _VariantCall::func_PackedByteArray_get_string_from_utf16, sarray(), varray());
bind_function("get_string_from_utf32", _VariantCall::func_PackedByteArray_get_string_from_utf32, sarray(), varray());
bind_function("hex_encode", _VariantCall::func_PackedByteArray_hex_encode, sarray(), varray());
Refactor MethodBind to use variadic templates Removed make_binders and the old style generated binders.
2020-10-15 17:29:59 +02:00
bind_function("compress", _VariantCall::func_PackedByteArray_compress, sarray("compression_mode"), varray(0));
bind_function("decompress", _VariantCall::func_PackedByteArray_decompress, sarray("buffer_size", "compression_mode"), varray(0));
bind_function("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 20:59:37 +02:00
/* Int32 Array */
bind_method(PackedInt32Array, size, sarray(), varray());
bind_method(PackedInt32Array, empty, sarray(), varray());
bind_method(PackedInt32Array, set, sarray("index", "value"), varray());
bind_method(PackedInt32Array, push_back, sarray("value"), varray());
bind_method(PackedInt32Array, append, sarray("value"), varray());
bind_method(PackedInt32Array, append_array, sarray("array"), varray());
bind_method(PackedInt32Array, remove, sarray("index"), varray());
bind_method(PackedInt32Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedInt32Array, resize, sarray("new_size"), varray());
bind_method(PackedInt32Array, has, sarray("value"), varray());
bind_method(PackedInt32Array, invert, sarray(), varray());
bind_method(PackedInt32Array, subarray, sarray("from", "to"), varray());
bind_method(PackedInt32Array, to_byte_array, sarray(), varray());
bind_method(PackedInt32Array, sort, sarray(), varray());
/* Int64 Array */
bind_method(PackedInt64Array, size, sarray(), varray());
bind_method(PackedInt64Array, empty, sarray(), varray());
bind_method(PackedInt64Array, set, sarray("index", "value"), varray());
bind_method(PackedInt64Array, push_back, sarray("value"), varray());
bind_method(PackedInt64Array, append, sarray("value"), varray());
bind_method(PackedInt64Array, append_array, sarray("array"), varray());
bind_method(PackedInt64Array, remove, sarray("index"), varray());
bind_method(PackedInt64Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedInt64Array, resize, sarray("new_size"), varray());
bind_method(PackedInt64Array, has, sarray("value"), varray());
bind_method(PackedInt64Array, invert, sarray(), varray());
bind_method(PackedInt64Array, subarray, sarray("from", "to"), varray());
bind_method(PackedInt64Array, to_byte_array, sarray(), varray());
bind_method(PackedInt64Array, sort, sarray(), varray());
/* Float32 Array */
bind_method(PackedFloat32Array, size, sarray(), varray());
bind_method(PackedFloat32Array, empty, sarray(), varray());
bind_method(PackedFloat32Array, set, sarray("index", "value"), varray());
bind_method(PackedFloat32Array, push_back, sarray("value"), varray());
bind_method(PackedFloat32Array, append, sarray("value"), varray());
bind_method(PackedFloat32Array, append_array, sarray("array"), varray());
bind_method(PackedFloat32Array, remove, sarray("index"), varray());
bind_method(PackedFloat32Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedFloat32Array, resize, sarray("new_size"), varray());
bind_method(PackedFloat32Array, has, sarray("value"), varray());
bind_method(PackedFloat32Array, invert, sarray(), varray());
bind_method(PackedFloat32Array, subarray, sarray("from", "to"), varray());
bind_method(PackedFloat32Array, to_byte_array, sarray(), varray());
bind_method(PackedFloat32Array, sort, sarray(), varray());
/* Float64 Array */
bind_method(PackedFloat64Array, size, sarray(), varray());
bind_method(PackedFloat64Array, empty, sarray(), varray());
bind_method(PackedFloat64Array, set, sarray("index", "value"), varray());
bind_method(PackedFloat64Array, push_back, sarray("value"), varray());
bind_method(PackedFloat64Array, append, sarray("value"), varray());
bind_method(PackedFloat64Array, append_array, sarray("array"), varray());
bind_method(PackedFloat64Array, remove, sarray("index"), varray());
bind_method(PackedFloat64Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedFloat64Array, resize, sarray("new_size"), varray());
bind_method(PackedFloat64Array, has, sarray("value"), varray());
bind_method(PackedFloat64Array, invert, sarray(), varray());
bind_method(PackedFloat64Array, subarray, sarray("from", "to"), varray());
bind_method(PackedFloat64Array, to_byte_array, sarray(), varray());
bind_method(PackedFloat64Array, sort, sarray(), varray());
/* String Array */
bind_method(PackedStringArray, size, sarray(), varray());
bind_method(PackedStringArray, empty, sarray(), varray());
bind_method(PackedStringArray, set, sarray("index", "value"), varray());
bind_method(PackedStringArray, push_back, sarray("value"), varray());
bind_method(PackedStringArray, append, sarray("value"), varray());
bind_method(PackedStringArray, append_array, sarray("array"), varray());
bind_method(PackedStringArray, remove, sarray("index"), varray());
bind_method(PackedStringArray, insert, sarray("at_index", "value"), varray());
bind_method(PackedStringArray, resize, sarray("new_size"), varray());
bind_method(PackedStringArray, has, sarray("value"), varray());
bind_method(PackedStringArray, invert, sarray(), varray());
bind_method(PackedStringArray, subarray, sarray("from", "to"), varray());
bind_method(PackedStringArray, to_byte_array, sarray(), varray());
bind_method(PackedStringArray, sort, sarray(), varray());
/* Vector2 Array */
bind_method(PackedVector2Array, size, sarray(), varray());
bind_method(PackedVector2Array, empty, sarray(), varray());
bind_method(PackedVector2Array, set, sarray("index", "value"), varray());
bind_method(PackedVector2Array, push_back, sarray("value"), varray());
bind_method(PackedVector2Array, append, sarray("value"), varray());
bind_method(PackedVector2Array, append_array, sarray("array"), varray());
bind_method(PackedVector2Array, remove, sarray("index"), varray());
bind_method(PackedVector2Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedVector2Array, resize, sarray("new_size"), varray());
bind_method(PackedVector2Array, has, sarray("value"), varray());
bind_method(PackedVector2Array, invert, sarray(), varray());
bind_method(PackedVector2Array, subarray, sarray("from", "to"), varray());
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());
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
/* Vector3 Array */
bind_method(PackedVector3Array, size, sarray(), varray());
bind_method(PackedVector3Array, empty, sarray(), varray());
bind_method(PackedVector3Array, set, sarray("index", "value"), varray());
bind_method(PackedVector3Array, push_back, sarray("value"), varray());
bind_method(PackedVector3Array, append, sarray("value"), varray());
bind_method(PackedVector3Array, append_array, sarray("array"), varray());
bind_method(PackedVector3Array, remove, sarray("index"), varray());
bind_method(PackedVector3Array, insert, sarray("at_index", "value"), varray());
bind_method(PackedVector3Array, resize, sarray("new_size"), varray());
bind_method(PackedVector3Array, has, sarray("value"), varray());
bind_method(PackedVector3Array, invert, sarray(), varray());
bind_method(PackedVector3Array, subarray, sarray("from", "to"), varray());
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());
Refactored binding system for core types Moved to a system using variadic templates, shared with CallableBind. New code is cleaner, faster and allows for much better optimization of core type functions from GDScript and GDNative. Added Variant::InternalMethod function for direct call access.
2020-10-13 20:59:37 +02:00
/* Color Array */
bind_method(PackedColorArray, size, sarray(), varray());
bind_method(PackedColorArray, empty, sarray(), varray());
bind_method(PackedColorArray, set, sarray("index", "value"), varray());
bind_method(PackedColorArray, push_back, sarray("value"), varray());
bind_method(PackedColorArray, append, sarray("value"), varray());
bind_method(PackedColorArray, append_array, sarray("array"), varray());
bind_method(PackedColorArray, remove, sarray("index"), varray());
bind_method(PackedColorArray, insert, sarray("at_index", "value"), varray());
bind_method(PackedColorArray, resize, sarray("new_size"), varray());
bind_method(PackedColorArray, has, sarray("value"), varray());
bind_method(PackedColorArray, invert, sarray(), varray());
bind_method(PackedColorArray, subarray, sarray("from", "to"), varray());
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());
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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
/* Register constants */
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01: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 23:33:38 +01: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
}
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
_VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X);
_VariantCall::add_constant(Variant::VECTOR3, "AXIS_Y", Vector3::AXIS_Y);
_VariantCall::add_constant(Variant::VECTOR3, "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-06 20:13:41 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "ONE", Vector3(1, 1, 1));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR3, "INF", Vector3(Math_INF, Math_INF, Math_INF));
_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));
Fix Vector3i and Vector2i AXIS_* constants
2020-08-05 10:45:28 +02:00
_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_X", Vector3i::AXIS_X);
_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_Y", Vector3i::AXIS_Y);
_VariantCall::add_constant(Variant::VECTOR3I, "AXIS_Z", Vector3i::AXIS_Z);
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 04:26:41 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR3I, "ZERO", Vector3i(0, 0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR3I, "ONE", Vector3i(1, 1, 1));
_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 Vector2/3 sign and posmod functions, misc additions Also make the docs more consistent, add Axis enum to Vector2, add > and >=. and C# also gets % and an override for vector-vector mod.
2019-08-05 03:50:28 +02:00
_VariantCall::add_constant(Variant::VECTOR2, "AXIS_X", Vector2::AXIS_X);
_VariantCall::add_constant(Variant::VECTOR2, "AXIS_Y", Vector2::AXIS_Y);
Fix Vector3i and Vector2i AXIS_* constants
2020-08-05 10:45:28 +02:00
_VariantCall::add_constant(Variant::VECTOR2I, "AXIS_X", Vector2i::AXIS_X);
_VariantCall::add_constant(Variant::VECTOR2I, "AXIS_Y", Vector2i::AXIS_Y);
Add support for Vector2i, Rect2i and Vector3i to Variant WARNING: Requires C++17 'guaranteed copy elision' to fix ambiguous operator problems in Variant. This was added for this commit (and future C++17 uses) in #36457.
2020-02-22 04:26:41 +01:00
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-06 20:13:41 +02:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "ONE", Vector2(1, 1));
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR2, "INF", Vector2(Math_INF, Math_INF));
_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 04:26:41 +01:00
_VariantCall::add_variant_constant(Variant::VECTOR2I, "ZERO", Vector2i(0, 0));
_VariantCall::add_variant_constant(Variant::VECTOR2I, "ONE", Vector2i(1, 1));
_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-09 05:29:45 +02: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));
Add Basis constants and format Transform constants
2019-08-09 05:29:45 +02:00
Transform identity_transform = Transform();
Transform flip_x_transform = Transform(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0);
Transform flip_y_transform = Transform(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0);
Transform flip_z_transform = Transform(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0);
Allow some non-integer built-in constants in gdscript
2017-12-15 16:43:27 +01:00
_VariantCall::add_variant_constant(Variant::TRANSFORM, "IDENTITY", identity_transform);
Add Basis constants and format Transform constants
2019-08-09 05:29:45 +02:00
_VariantCall::add_variant_constant(Variant::TRANSFORM, "FLIP_X", flip_x_transform);
_VariantCall::add_variant_constant(Variant::TRANSFORM, "FLIP_Y", flip_y_transform);
_VariantCall::add_variant_constant(Variant::TRANSFORM, "FLIP_Z", flip_z_transform);
Basis identity_basis = Basis();
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 07:34:34 +02: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
_VariantCall::add_variant_constant(Variant::QUAT, "IDENTITY", Quat(0, 0, 0, 1));
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Refactored variant constructor logic
2020-11-09 04:19:09 +01: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 20:59:37 +02:00
//clear methods
for (int i = 0; i < Variant::VARIANT_MAX; i++) {
for (List<StringName>::Element *E = _VariantCall::type_internal_method_names[i].front(); E; E = E->next()) {
Variant::InternalMethod **m = _VariantCall::type_internal_methods[i].lookup_ptr(E->get());
if (*m) {
memdelete(*m);
}
}
}
memdelete_arr(_VariantCall::type_internal_methods);
memdelete_arr(_VariantCall::type_internal_method_names);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 16:44:50 +01:00
memdelete_arr(_VariantCall::constant_data);
GODOT IS OPEN SOURCE
2014-02-10 02:10:30 +01:00
}
Reference in a new issue Copy permalink