core_bind.cpp | Explore in Territory

/**************************************************************************/
/*  core_bind.cpp                                                         */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "core_bind.h"
#include "core_bind.compat.inc"

#include "core/config/project_settings.h"
#include "core/crypto/crypto_core.h"
#include "core/debugger/engine_debugger.h"
#include "core/debugger/script_debugger.h"
#include "core/io/file_access_compressed.h"
#include "core/io/file_access_encrypted.h"
#include "core/io/marshalls.h"
#include "core/math/geometry_2d.h"
#include "core/math/geometry_3d.h"
#include "core/os/keyboard.h"
#include "core/os/thread_safe.h"
#include "core/variant/typed_array.h"

namespace core_bind {

////// ResourceLoader //////

ResourceLoader *ResourceLoader::singleton = …;

Error ResourceLoader::load_threaded_request(const String &p_path, const String &p_type_hint, bool p_use_sub_threads, CacheMode p_cache_mode) { … }

ResourceLoader::ThreadLoadStatus ResourceLoader::load_threaded_get_status(const String &p_path, Array r_progress) { … }

Ref<Resource> ResourceLoader::load_threaded_get(const String &p_path) { … }

Ref<Resource> ResourceLoader::load(const String &p_path, const String &p_type_hint, CacheMode p_cache_mode) { … }

Vector<String> ResourceLoader::get_recognized_extensions_for_type(const String &p_type) { … }

void ResourceLoader::add_resource_format_loader(Ref<ResourceFormatLoader> p_format_loader, bool p_at_front) { … }

void ResourceLoader::remove_resource_format_loader(Ref<ResourceFormatLoader> p_format_loader) { … }

void ResourceLoader::set_abort_on_missing_resources(bool p_abort) { … }

PackedStringArray ResourceLoader::get_dependencies(const String &p_path) { … }

bool ResourceLoader::has_cached(const String &p_path) { … }

Ref<Resource> ResourceLoader::get_cached_ref(const String &p_path) { … }

bool ResourceLoader::exists(const String &p_path, const String &p_type_hint) { … }

ResourceUID::ID ResourceLoader::get_resource_uid(const String &p_path) { … }

void ResourceLoader::_bind_methods() { … }

////// ResourceSaver //////

Error ResourceSaver::save(const Ref<Resource> &p_resource, const String &p_path, BitField<SaverFlags> p_flags) { … }

Vector<String> ResourceSaver::get_recognized_extensions(const Ref<Resource> &p_resource) { … }

void ResourceSaver::add_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver, bool p_at_front) { … }

void ResourceSaver::remove_resource_format_saver(Ref<ResourceFormatSaver> p_format_saver) { … }

ResourceUID::ID ResourceSaver::get_resource_id_for_path(const String &p_path, bool p_generate) { … }

ResourceSaver *ResourceSaver::singleton = …;

void ResourceSaver::_bind_methods() { … }

////// OS //////

PackedByteArray OS::get_entropy(int p_bytes) { … }

String OS::get_system_ca_certificates() { … }

PackedStringArray OS::get_connected_midi_inputs() { … }

void OS::open_midi_inputs() { … }

void OS::close_midi_inputs() { … }

void OS::set_use_file_access_save_and_swap(bool p_enable) { … }

void OS::set_low_processor_usage_mode(bool p_enabled) { … }

bool OS::is_in_low_processor_usage_mode() const { … }

void OS::set_low_processor_usage_mode_sleep_usec(int p_usec) { … }

int OS::get_low_processor_usage_mode_sleep_usec() const { … }

void OS::set_delta_smoothing(bool p_enabled) { … }

bool OS::is_delta_smoothing_enabled() const { … }

void OS::alert(const String &p_alert, const String &p_title) { … }

void OS::crash(const String &p_message) { … }

Vector<String> OS::get_system_fonts() const { … }

String OS::get_system_font_path(const String &p_font_name, int p_weight, int p_stretch, bool p_italic) const { … }

Vector<String> OS::get_system_font_path_for_text(const String &p_font_name, const String &p_text, const String &p_locale, const String &p_script, int p_weight, int p_stretch, bool p_italic) const { … }

String OS::get_executable_path() const { … }

Error OS::shell_open(const String &p_uri) { … }

Error OS::shell_show_in_file_manager(const String &p_path, bool p_open_folder) { … }

String OS::read_string_from_stdin() { … }

int OS::execute(const String &p_path, const Vector<String> &p_arguments, Array r_output, bool p_read_stderr, bool p_open_console) { … }

Dictionary OS::execute_with_pipe(const String &p_path, const Vector<String> &p_arguments, bool p_blocking) { … }

int OS::create_instance(const Vector<String> &p_arguments) { … }

int OS::create_process(const String &p_path, const Vector<String> &p_arguments, bool p_open_console) { … }

Error OS::kill(int p_pid) { … }

bool OS::is_process_running(int p_pid) const { … }

int OS::get_process_exit_code(int p_pid) const { … }

int OS::get_process_id() const { … }

bool OS::has_environment(const String &p_var) const { … }

String OS::get_environment(const String &p_var) const { … }

void OS::set_environment(const String &p_var, const String &p_value) const { … }

void OS::unset_environment(const String &p_var) const { … }

String OS::get_name() const { … }

String OS::get_distribution_name() const { … }

String OS::get_version() const { … }

Vector<String> OS::get_video_adapter_driver_info() const { … }

Vector<String> OS::get_cmdline_args() { … }

Vector<String> OS::get_cmdline_user_args() { … }

void OS::set_restart_on_exit(bool p_restart, const Vector<String> &p_restart_arguments) { … }

bool OS::is_restart_on_exit_set() const { … }

Vector<String> OS::get_restart_on_exit_arguments() const { … }

String OS::get_locale() const { … }

String OS::get_locale_language() const { … }

String OS::get_model_name() const { … }

Error OS::set_thread_name(const String &p_name) { … }

::Thread::ID OS::get_thread_caller_id() const {
	return ::Thread::get_caller_id();
};

::Thread::ID OS::get_main_thread_id() const {
	return ::Thread::get_main_id();
};

bool OS::has_feature(const String &p_feature) const { … }

bool OS::is_sandboxed() const { … }

uint64_t OS::get_static_memory_usage() const { … }

uint64_t OS::get_static_memory_peak_usage() const { … }

Dictionary OS::get_memory_info() const { … }

/** This method uses a signed argument for better error reporting as it's used from the scripting API. */
void OS::delay_usec(int p_usec) const { … }

/** This method uses a signed argument for better error reporting as it's used from the scripting API. */
void OS::delay_msec(int p_msec) const { … }

bool OS::is_userfs_persistent() const { … }

int OS::get_processor_count() const { … }

String OS::get_processor_name() const { … }

bool OS::is_stdout_verbose() const { … }

Error OS::move_to_trash(const String &p_path) const { … }

String OS::get_user_data_dir() const { … }

String OS::get_config_dir() const { … }

String OS::get_data_dir() const { … }

String OS::get_cache_dir() const { … }

bool OS::is_debug_build() const { … }

String OS::get_system_dir(SystemDir p_dir, bool p_shared_storage) const { … }

String OS::get_keycode_string(Key p_code) const { … }

bool OS::is_keycode_unicode(char32_t p_unicode) const { … }

Key OS::find_keycode_from_string(const String &p_code) const { … }

bool OS::request_permission(const String &p_name) { … }

bool OS::request_permissions() { … }

Vector<String> OS::get_granted_permissions() const { … }

void OS::revoke_granted_permissions() { … }

String OS::get_unique_id() const { … }

OS *OS::singleton = …;

void OS::_bind_methods() { … }

////// Geometry2D //////

Geometry2D *Geometry2D::singleton = …;

Geometry2D *Geometry2D::get_singleton() { … }

bool Geometry2D::is_point_in_circle(const Vector2 &p_point, const Vector2 &p_circle_pos, real_t p_circle_radius) { … }

real_t Geometry2D::segment_intersects_circle(const Vector2 &p_from, const Vector2 &p_to, const Vector2 &p_circle_pos, real_t p_circle_radius) { … }

Variant Geometry2D::segment_intersects_segment(const Vector2 &p_from_a, const Vector2 &p_to_a, const Vector2 &p_from_b, const Vector2 &p_to_b) { … }

Variant Geometry2D::line_intersects_line(const Vector2 &p_from_a, const Vector2 &p_dir_a, const Vector2 &p_from_b, const Vector2 &p_dir_b) { … }

Vector<Vector2> Geometry2D::get_closest_points_between_segments(const Vector2 &p1, const Vector2 &q1, const Vector2 &p2, const Vector2 &q2) { … }

Vector2 Geometry2D::get_closest_point_to_segment(const Vector2 &p_point, const Vector2 &p_a, const Vector2 &p_b) { … }

Vector2 Geometry2D::get_closest_point_to_segment_uncapped(const Vector2 &p_point, const Vector2 &p_a, const Vector2 &p_b) { … }

bool Geometry2D::point_is_inside_triangle(const Vector2 &s, const Vector2 &a, const Vector2 &b, const Vector2 &c) const { … }

bool Geometry2D::is_polygon_clockwise(const Vector<Vector2> &p_polygon) { … }

bool Geometry2D::is_point_in_polygon(const Point2 &p_point, const Vector<Vector2> &p_polygon) { … }

Vector<int> Geometry2D::triangulate_polygon(const Vector<Vector2> &p_polygon) { … }

Vector<int> Geometry2D::triangulate_delaunay(const Vector<Vector2> &p_points) { … }

Vector<Point2> Geometry2D::convex_hull(const Vector<Point2> &p_points) { … }

TypedArray<PackedVector2Array> Geometry2D::decompose_polygon_in_convex(const Vector<Vector2> &p_polygon) { … }

TypedArray<PackedVector2Array> Geometry2D::merge_polygons(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b) { … }

TypedArray<PackedVector2Array> Geometry2D::clip_polygons(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b) { … }

TypedArray<PackedVector2Array> Geometry2D::intersect_polygons(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b) { … }

TypedArray<PackedVector2Array> Geometry2D::exclude_polygons(const Vector<Vector2> &p_polygon_a, const Vector<Vector2> &p_polygon_b) { … }

TypedArray<PackedVector2Array> Geometry2D::clip_polyline_with_polygon(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon) { … }

TypedArray<PackedVector2Array> Geometry2D::intersect_polyline_with_polygon(const Vector<Vector2> &p_polyline, const Vector<Vector2> &p_polygon) { … }

TypedArray<PackedVector2Array> Geometry2D::offset_polygon(const Vector<Vector2> &p_polygon, real_t p_delta, PolyJoinType p_join_type) { … }

TypedArray<PackedVector2Array> Geometry2D::offset_polyline(const Vector<Vector2> &p_polygon, real_t p_delta, PolyJoinType p_join_type, PolyEndType p_end_type) { … }

Dictionary Geometry2D::make_atlas(const Vector<Size2> &p_rects) { … }

void Geometry2D::_bind_methods() { … }

////// Geometry3D //////

Geometry3D *Geometry3D::singleton = …;

Geometry3D *Geometry3D::get_singleton() { … }

Vector<Vector3> Geometry3D::compute_convex_mesh_points(const TypedArray<Plane> &p_planes) { … }

TypedArray<Plane> Geometry3D::build_box_planes(const Vector3 &p_extents) { … }

TypedArray<Plane> Geometry3D::build_cylinder_planes(float p_radius, float p_height, int p_sides, Vector3::Axis p_axis) { … }

TypedArray<Plane> Geometry3D::build_capsule_planes(float p_radius, float p_height, int p_sides, int p_lats, Vector3::Axis p_axis) { … }

Vector<Vector3> Geometry3D::get_closest_points_between_segments(const Vector3 &p1, const Vector3 &p2, const Vector3 &q1, const Vector3 &q2) { … }

Vector3 Geometry3D::get_closest_point_to_segment(const Vector3 &p_point, const Vector3 &p_a, const Vector3 &p_b) { … }

Vector3 Geometry3D::get_closest_point_to_segment_uncapped(const Vector3 &p_point, const Vector3 &p_a, const Vector3 &p_b) { … }

Vector3 Geometry3D::get_triangle_barycentric_coords(const Vector3 &p_point, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2) { … }

Variant Geometry3D::ray_intersects_triangle(const Vector3 &p_from, const Vector3 &p_dir, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2) { … }

Variant Geometry3D::segment_intersects_triangle(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_v0, const Vector3 &p_v1, const Vector3 &p_v2) { … }

Vector<Vector3> Geometry3D::segment_intersects_sphere(const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_sphere_pos, real_t p_sphere_radius) { … }

Vector<Vector3> Geometry3D::segment_intersects_cylinder(const Vector3 &p_from, const Vector3 &p_to, float p_height, float p_radius) { … }

Vector<Vector3> Geometry3D::segment_intersects_convex(const Vector3 &p_from, const Vector3 &p_to, const TypedArray<Plane> &p_planes) { … }

Vector<Vector3> Geometry3D::clip_polygon(const Vector<Vector3> &p_points, const Plane &p_plane) { … }

Vector<int32_t> Geometry3D::tetrahedralize_delaunay(const Vector<Vector3> &p_points) { … }

void Geometry3D::_bind_methods() { … }

////// Marshalls //////

Marshalls *Marshalls::singleton = …;

Marshalls *Marshalls::get_singleton() { … }

String Marshalls::variant_to_base64(const Variant &p_var, bool p_full_objects) { … }

Variant Marshalls::base64_to_variant(const String &p_str, bool p_allow_objects) { … }

String Marshalls::raw_to_base64(const Vector<uint8_t> &p_arr) { … }

Vector<uint8_t> Marshalls::base64_to_raw(const String &p_str) { … }

String Marshalls::utf8_to_base64(const String &p_str) { … }

String Marshalls::base64_to_utf8(const String &p_str) { … }

void Marshalls::_bind_methods() { … }

////// Semaphore //////

void Semaphore::wait() { … }

bool Semaphore::try_wait() { … }

void Semaphore::post(int p_count) { … }

void Semaphore::_bind_methods() { … }

////// Mutex //////

void Mutex::lock() { … }

bool Mutex::try_lock() { … }

void Mutex::unlock() { … }

void Mutex::_bind_methods() { … }

////// Thread //////

void Thread::_start_func(void *ud) { … }

Error Thread::start(const Callable &p_callable, Priority p_priority) { … }

String Thread::get_id() const { … }

bool Thread::is_started() const { … }

bool Thread::is_alive() const { … }

Variant Thread::wait_to_finish() { … }

void Thread::set_thread_safety_checks_enabled(bool p_enabled) { … }

void Thread::_bind_methods() { … }

namespace special {

////// ClassDB //////

PackedStringArray ClassDB::get_class_list() const { … }

PackedStringArray ClassDB::get_inheriters_from_class(const StringName &p_class) const { … }

StringName ClassDB::get_parent_class(const StringName &p_class) const { … }

bool ClassDB::class_exists(const StringName &p_class) const { … }

bool ClassDB::is_parent_class(const StringName &p_class, const StringName &p_inherits) const { … }

bool ClassDB::can_instantiate(const StringName &p_class) const { … }

Variant ClassDB::instantiate(const StringName &p_class) const { … }

ClassDB::APIType ClassDB::class_get_api_type(const StringName &p_class) const { … }

bool ClassDB::class_has_signal(const StringName &p_class, const StringName &p_signal) const { … }

Dictionary ClassDB::class_get_signal(const StringName &p_class, const StringName &p_signal) const { … }

TypedArray<Dictionary> ClassDB::class_get_signal_list(const StringName &p_class, bool p_no_inheritance) const { … }

TypedArray<Dictionary> ClassDB::class_get_property_list(const StringName &p_class, bool p_no_inheritance) const { … }

StringName ClassDB::class_get_property_getter(const StringName &p_class, const StringName &p_property) { … }

StringName ClassDB::class_get_property_setter(const StringName &p_class, const StringName &p_property) { … }

Variant ClassDB::class_get_property(Object *p_object, const StringName &p_property) const { … }

Error ClassDB::class_set_property(Object *p_object, const StringName &p_property, const Variant &p_value) const { … }

Variant ClassDB::class_get_property_default_value(const StringName &p_class, const StringName &p_property) const { … }

bool ClassDB::class_has_method(const StringName &p_class, const StringName &p_method, bool p_no_inheritance) const { … }

int ClassDB::class_get_method_argument_count(const StringName &p_class, const StringName &p_method, bool p_no_inheritance) const { … }

TypedArray<Dictionary> ClassDB::class_get_method_list(const StringName &p_class, bool p_no_inheritance) const { … }

Variant ClassDB::class_call_static_method(const Variant **p_arguments, int p_argcount, Callable::CallError &r_call_error) { … }

PackedStringArray ClassDB::class_get_integer_constant_list(const StringName &p_class, bool p_no_inheritance) const { … }

bool ClassDB::class_has_integer_constant(const StringName &p_class, const StringName &p_name) const { … }

int64_t ClassDB::class_get_integer_constant(const StringName &p_class, const StringName &p_name) const { … }

bool ClassDB::class_has_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const { … }

PackedStringArray ClassDB::class_get_enum_list(const StringName &p_class, bool p_no_inheritance) const { … }

PackedStringArray ClassDB::class_get_enum_constants(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance) const { … }

StringName ClassDB::class_get_integer_constant_enum(const StringName &p_class, const StringName &p_name, bool p_no_inheritance) const { … }

bool ClassDB::is_class_enum_bitfield(const StringName &p_class, const StringName &p_enum, bool p_no_inheritance) const { … }

bool ClassDB::is_class_enabled(const StringName &p_class) const { … }

#ifdef TOOLS_ENABLED
void ClassDB::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const { … }
#endif

void ClassDB::_bind_methods() { … }

} // namespace special

////// Engine //////

void Engine::set_physics_ticks_per_second(int p_ips) { … }

int Engine::get_physics_ticks_per_second() const { … }

void Engine::set_max_physics_steps_per_frame(int p_max_physics_steps) { … }

int Engine::get_max_physics_steps_per_frame() const { … }

void Engine::set_physics_jitter_fix(double p_threshold) { … }

double Engine::get_physics_jitter_fix() const { … }

double Engine::get_physics_interpolation_fraction() const { … }

void Engine::set_max_fps(int p_fps) { … }

int Engine::get_max_fps() const { … }

double Engine::get_frames_per_second() const { … }

uint64_t Engine::get_physics_frames() const { … }

uint64_t Engine::get_process_frames() const { … }

void Engine::set_time_scale(double p_scale) { … }

double Engine::get_time_scale() { … }

int Engine::get_frames_drawn() { … }

MainLoop *Engine::get_main_loop() const { … }

Dictionary Engine::get_version_info() const { … }

Dictionary Engine::get_author_info() const { … }

TypedArray<Dictionary> Engine::get_copyright_info() const { … }

Dictionary Engine::get_donor_info() const { … }

Dictionary Engine::get_license_info() const { … }

String Engine::get_license_text() const { … }

String Engine::get_architecture_name() const { … }

bool Engine::is_in_physics_frame() const { … }

bool Engine::has_singleton(const StringName &p_name) const { … }

Object *Engine::get_singleton_object(const StringName &p_name) const { … }

void Engine::register_singleton(const StringName &p_name, Object *p_object) { … }

void Engine::unregister_singleton(const StringName &p_name) { … }

Vector<String> Engine::get_singleton_list() const { … }

Error Engine::register_script_language(ScriptLanguage *p_language) { … }

Error Engine::unregister_script_language(const ScriptLanguage *p_language) { … }

int Engine::get_script_language_count() { … }

ScriptLanguage *Engine::get_script_language(int p_index) const { … }

void Engine::set_editor_hint(bool p_enabled) { … }

bool Engine::is_editor_hint() const { … }

String Engine::get_write_movie_path() const { … }

void Engine::set_print_to_stdout(bool p_enabled) { … }

bool Engine::is_printing_to_stdout() const { … }

void Engine::set_print_error_messages(bool p_enabled) { … }

bool Engine::is_printing_error_messages() const { … }

#ifdef TOOLS_ENABLED
void Engine::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const { … }
#endif

void Engine::_bind_methods() { … }

Engine *Engine::singleton = …;

////// EngineDebugger //////

bool EngineDebugger::is_active() { … }

void EngineDebugger::register_profiler(const StringName &p_name, Ref<EngineProfiler> p_profiler) { … }

void EngineDebugger::unregister_profiler(const StringName &p_name) { … }

bool EngineDebugger::is_profiling(const StringName &p_name) { … }

bool EngineDebugger::has_profiler(const StringName &p_name) { … }

void EngineDebugger::profiler_add_frame_data(const StringName &p_name, const Array &p_data) { … }

void EngineDebugger::profiler_enable(const StringName &p_name, bool p_enabled, const Array &p_opts) { … }

void EngineDebugger::register_message_capture(const StringName &p_name, const Callable &p_callable) { … }

void EngineDebugger::unregister_message_capture(const StringName &p_name) { … }

bool EngineDebugger::has_capture(const StringName &p_name) { … }

void EngineDebugger::send_message(const String &p_msg, const Array &p_data) { … }

void EngineDebugger::debug(bool p_can_continue, bool p_is_error_breakpoint) { … }

void EngineDebugger::script_debug(ScriptLanguage *p_lang, bool p_can_continue, bool p_is_error_breakpoint) { … }

Error EngineDebugger::call_capture(void *p_user, const String &p_cmd, const Array &p_data, bool &r_captured) { … }

void EngineDebugger::line_poll() { … }

void EngineDebugger::set_lines_left(int p_lines) { … }

int EngineDebugger::get_lines_left() const { … }

void EngineDebugger::set_depth(int p_depth) { … }

int EngineDebugger::get_depth() const { … }

bool EngineDebugger::is_breakpoint(int p_line, const StringName &p_source) const { … }

bool EngineDebugger::is_skipping_breakpoints() const { … }

void EngineDebugger::insert_breakpoint(int p_line, const StringName &p_source) { … }

void EngineDebugger::remove_breakpoint(int p_line, const StringName &p_source) { … }

void EngineDebugger::clear_breakpoints() { … }

EngineDebugger::~EngineDebugger() { … }

EngineDebugger *EngineDebugger::singleton = …;

void EngineDebugger::_bind_methods() { … }

} // namespace core_bind
godot/core/core_bind.cpp
