godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
c3f2364c10f397e3718d45ebd79eda715f38f8e0
godot-docs-l10n/classes/es/class_@globalscope.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

7622 lines
343 KiB
ReStructuredText
Raw Blame History

:github_url: hide
.. _class_@GlobalScope:
@GlobalScope
============
Constantes de ámbito global y funciones.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Una lista de constantes enumeradas de ámbito global y funciones integradas. Esto es todo lo que reside en las variables globales, constantes relacionadas con códigos de error, códigos de teclas, sugerencias de propiedades, etc.
Los singletons también se documentan aquí, ya que se puede acceder a ellos desde cualquier lugar.
Para las entradas a las que solo se puede acceder desde scripts escritos en GDScript, Véase :ref:`@GDScript<class_@GDScript>`.
.. note::
Hay diferencias notables cuando usa esta API con C#. Véase :ref:`doc_c_sharp_differences` para más información.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Generación de números aleatorios <../tutorials/math/random_number_generation>`
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`AudioServer<class_AudioServer>` | :ref:`AudioServer<class_@GlobalScope_property_AudioServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`CameraServer<class_CameraServer>` | :ref:`CameraServer<class_@GlobalScope_property_CameraServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ClassDB<class_ClassDB>` | :ref:`ClassDB<class_@GlobalScope_property_ClassDB>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`DisplayServer<class_DisplayServer>` | :ref:`DisplayServer<class_@GlobalScope_property_DisplayServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`EditorInterface<class_EditorInterface>` | :ref:`EditorInterface<class_@GlobalScope_property_EditorInterface>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Engine<class_Engine>` | :ref:`Engine<class_@GlobalScope_property_Engine>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`EngineDebugger<class_EngineDebugger>` | :ref:`EngineDebugger<class_@GlobalScope_property_EngineDebugger>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`GDExtensionManager<class_GDExtensionManager>` | :ref:`GDExtensionManager<class_@GlobalScope_property_GDExtensionManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Geometry2D<class_Geometry2D>` | :ref:`Geometry2D<class_@GlobalScope_property_Geometry2D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Geometry3D<class_Geometry3D>` | :ref:`Geometry3D<class_@GlobalScope_property_Geometry3D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`IP<class_IP>` | :ref:`IP<class_@GlobalScope_property_IP>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Input<class_Input>` | :ref:`Input<class_@GlobalScope_property_Input>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`InputMap<class_InputMap>` | :ref:`InputMap<class_@GlobalScope_property_InputMap>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`JavaClassWrapper<class_JavaClassWrapper>` | :ref:`JavaClassWrapper<class_@GlobalScope_property_JavaClassWrapper>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`JavaScriptBridge<class_JavaScriptBridge>` | :ref:`JavaScriptBridge<class_@GlobalScope_property_JavaScriptBridge>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Marshalls<class_Marshalls>` | :ref:`Marshalls<class_@GlobalScope_property_Marshalls>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NativeMenu<class_NativeMenu>` | :ref:`NativeMenu<class_@GlobalScope_property_NativeMenu>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>` | :ref:`NavigationMeshGenerator<class_@GlobalScope_property_NavigationMeshGenerator>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NavigationServer2D<class_NavigationServer2D>` | :ref:`NavigationServer2D<class_@GlobalScope_property_NavigationServer2D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NavigationServer2DManager<class_NavigationServer2DManager>` | :ref:`NavigationServer2DManager<class_@GlobalScope_property_NavigationServer2DManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NavigationServer3D<class_NavigationServer3D>` | :ref:`NavigationServer3D<class_@GlobalScope_property_NavigationServer3D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`NavigationServer3DManager<class_NavigationServer3DManager>` | :ref:`NavigationServer3DManager<class_@GlobalScope_property_NavigationServer3DManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`OS<class_OS>` | :ref:`OS<class_@GlobalScope_property_OS>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Performance<class_Performance>` | :ref:`Performance<class_@GlobalScope_property_Performance>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`PhysicsServer2D<class_PhysicsServer2D>` | :ref:`PhysicsServer2D<class_@GlobalScope_property_PhysicsServer2D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>` | :ref:`PhysicsServer2DManager<class_@GlobalScope_property_PhysicsServer2DManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`PhysicsServer3D<class_PhysicsServer3D>` | :ref:`PhysicsServer3D<class_@GlobalScope_property_PhysicsServer3D>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>` | :ref:`PhysicsServer3DManager<class_@GlobalScope_property_PhysicsServer3DManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ProjectSettings<class_ProjectSettings>` | :ref:`ProjectSettings<class_@GlobalScope_property_ProjectSettings>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`RenderingServer<class_RenderingServer>` | :ref:`RenderingServer<class_@GlobalScope_property_RenderingServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ResourceLoader<class_ResourceLoader>` | :ref:`ResourceLoader<class_@GlobalScope_property_ResourceLoader>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ResourceSaver<class_ResourceSaver>` | :ref:`ResourceSaver<class_@GlobalScope_property_ResourceSaver>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ResourceUID<class_ResourceUID>` | :ref:`ResourceUID<class_@GlobalScope_property_ResourceUID>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`TextServerManager<class_TextServerManager>` | :ref:`TextServerManager<class_@GlobalScope_property_TextServerManager>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`ThemeDB<class_ThemeDB>` | :ref:`ThemeDB<class_@GlobalScope_property_ThemeDB>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`Time<class_Time>` | :ref:`Time<class_@GlobalScope_property_Time>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`TranslationServer<class_TranslationServer>` | :ref:`TranslationServer<class_@GlobalScope_property_TranslationServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`WorkerThreadPool<class_WorkerThreadPool>` | :ref:`WorkerThreadPool<class_@GlobalScope_property_WorkerThreadPool>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
| :ref:`XRServer<class_XRServer>` | :ref:`XRServer<class_@GlobalScope_property_XRServer>` |
+-------------------------------------------------------------------+-----------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`abs<class_@GlobalScope_method_abs>`\ (\ x\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`absf<class_@GlobalScope_method_absf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`absi<class_@GlobalScope_method_absi>`\ (\ x\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`acos<class_@GlobalScope_method_acos>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`acosh<class_@GlobalScope_method_acosh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`angle_difference<class_@GlobalScope_method_angle_difference>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`asin<class_@GlobalScope_method_asin>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`asinh<class_@GlobalScope_method_asinh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`atan<class_@GlobalScope_method_atan>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`atan2<class_@GlobalScope_method_atan2>`\ (\ y\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`atanh<class_@GlobalScope_method_atanh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`bezier_derivative<class_@GlobalScope_method_bezier_derivative>`\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`bezier_interpolate<class_@GlobalScope_method_bezier_interpolate>`\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`bytes_to_var<class_@GlobalScope_method_bytes_to_var>`\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`bytes_to_var_with_objects<class_@GlobalScope_method_bytes_to_var_with_objects>`\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`ceil<class_@GlobalScope_method_ceil>`\ (\ x\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`ceilf<class_@GlobalScope_method_ceilf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`ceili<class_@GlobalScope_method_ceili>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`clamp<class_@GlobalScope_method_clamp>`\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`clampf<class_@GlobalScope_method_clampf>`\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`clampi<class_@GlobalScope_method_clampi>`\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cos<class_@GlobalScope_method_cos>`\ (\ angle_rad\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cosh<class_@GlobalScope_method_cosh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cubic_interpolate<class_@GlobalScope_method_cubic_interpolate>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cubic_interpolate_angle<class_@GlobalScope_method_cubic_interpolate_angle>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cubic_interpolate_angle_in_time<class_@GlobalScope_method_cubic_interpolate_angle_in_time>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`cubic_interpolate_in_time<class_@GlobalScope_method_cubic_interpolate_in_time>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`db_to_linear<class_@GlobalScope_method_db_to_linear>`\ (\ db\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`deg_to_rad<class_@GlobalScope_method_deg_to_rad>`\ (\ deg\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`ease<class_@GlobalScope_method_ease>`\ (\ x\: :ref:`float<class_float>`, curve\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`error_string<class_@GlobalScope_method_error_string>`\ (\ error\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`exp<class_@GlobalScope_method_exp>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`floor<class_@GlobalScope_method_floor>`\ (\ x\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`floorf<class_@GlobalScope_method_floorf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`floori<class_@GlobalScope_method_floori>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`fmod<class_@GlobalScope_method_fmod>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`fposmod<class_@GlobalScope_method_fposmod>`\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hash<class_@GlobalScope_method_hash>`\ (\ variable\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Object<class_Object>` | :ref:`instance_from_id<class_@GlobalScope_method_instance_from_id>`\ (\ instance_id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`inverse_lerp<class_@GlobalScope_method_inverse_lerp>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_@GlobalScope_method_is_equal_approx>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_finite<class_@GlobalScope_method_is_finite>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_inf<class_@GlobalScope_method_is_inf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_instance_id_valid<class_@GlobalScope_method_is_instance_id_valid>`\ (\ id\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_instance_valid<class_@GlobalScope_method_is_instance_valid>`\ (\ instance\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_nan<class_@GlobalScope_method_is_nan>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_same<class_@GlobalScope_method_is_same>`\ (\ a\: :ref:`Variant<class_Variant>`, b\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_zero_approx<class_@GlobalScope_method_is_zero_approx>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`lerp<class_@GlobalScope_method_lerp>`\ (\ from\: :ref:`Variant<class_Variant>`, to\: :ref:`Variant<class_Variant>`, weight\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`lerp_angle<class_@GlobalScope_method_lerp_angle>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`lerpf<class_@GlobalScope_method_lerpf>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`linear_to_db<class_@GlobalScope_method_linear_to_db>`\ (\ lin\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`log<class_@GlobalScope_method_log>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`max<class_@GlobalScope_method_max>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`maxf<class_@GlobalScope_method_maxf>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`maxi<class_@GlobalScope_method_maxi>`\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`min<class_@GlobalScope_method_min>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`minf<class_@GlobalScope_method_minf>`\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`mini<class_@GlobalScope_method_mini>`\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`move_toward<class_@GlobalScope_method_move_toward>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`nearest_po2<class_@GlobalScope_method_nearest_po2>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`pingpong<class_@GlobalScope_method_pingpong>`\ (\ value\: :ref:`float<class_float>`, length\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`posmod<class_@GlobalScope_method_posmod>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`pow<class_@GlobalScope_method_pow>`\ (\ base\: :ref:`float<class_float>`, exp\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`print<class_@GlobalScope_method_print>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`print_rich<class_@GlobalScope_method_print_rich>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`print_verbose<class_@GlobalScope_method_print_verbose>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`printerr<class_@GlobalScope_method_printerr>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`printraw<class_@GlobalScope_method_printraw>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`prints<class_@GlobalScope_method_prints>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`printt<class_@GlobalScope_method_printt>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_error<class_@GlobalScope_method_push_error>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_warning<class_@GlobalScope_method_push_warning>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`rad_to_deg<class_@GlobalScope_method_rad_to_deg>`\ (\ rad\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`rand_from_seed<class_@GlobalScope_method_rand_from_seed>`\ (\ seed\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`randf<class_@GlobalScope_method_randf>`\ (\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`randf_range<class_@GlobalScope_method_randf_range>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`randfn<class_@GlobalScope_method_randfn>`\ (\ mean\: :ref:`float<class_float>`, deviation\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`randi<class_@GlobalScope_method_randi>`\ (\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`randi_range<class_@GlobalScope_method_randi_range>`\ (\ from\: :ref:`int<class_int>`, to\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`randomize<class_@GlobalScope_method_randomize>`\ (\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`remap<class_@GlobalScope_method_remap>`\ (\ value\: :ref:`float<class_float>`, istart\: :ref:`float<class_float>`, istop\: :ref:`float<class_float>`, ostart\: :ref:`float<class_float>`, ostop\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rid_allocate_id<class_@GlobalScope_method_rid_allocate_id>`\ (\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`rid_from_int64<class_@GlobalScope_method_rid_from_int64>`\ (\ base\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`rotate_toward<class_@GlobalScope_method_rotate_toward>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`round<class_@GlobalScope_method_round>`\ (\ x\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`roundf<class_@GlobalScope_method_roundf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`roundi<class_@GlobalScope_method_roundi>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`seed<class_@GlobalScope_method_seed>`\ (\ base\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`sign<class_@GlobalScope_method_sign>`\ (\ x\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`signf<class_@GlobalScope_method_signf>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`signi<class_@GlobalScope_method_signi>`\ (\ x\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`sin<class_@GlobalScope_method_sin>`\ (\ angle_rad\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`sinh<class_@GlobalScope_method_sinh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`smoothstep<class_@GlobalScope_method_smoothstep>`\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`snapped<class_@GlobalScope_method_snapped>`\ (\ x\: :ref:`Variant<class_Variant>`, step\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`snappedf<class_@GlobalScope_method_snappedf>`\ (\ x\: :ref:`float<class_float>`, step\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`snappedi<class_@GlobalScope_method_snappedi>`\ (\ x\: :ref:`float<class_float>`, step\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`sqrt<class_@GlobalScope_method_sqrt>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`step_decimals<class_@GlobalScope_method_step_decimals>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`str<class_@GlobalScope_method_str>`\ (\ ...\ ) |vararg| |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`str_to_var<class_@GlobalScope_method_str_to_var>`\ (\ string\: :ref:`String<class_String>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`tan<class_@GlobalScope_method_tan>`\ (\ angle_rad\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`tanh<class_@GlobalScope_method_tanh>`\ (\ x\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`type_convert<class_@GlobalScope_method_type_convert>`\ (\ variant\: :ref:`Variant<class_Variant>`, type\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`type_string<class_@GlobalScope_method_type_string>`\ (\ type\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`typeof<class_@GlobalScope_method_typeof>`\ (\ variable\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`var_to_bytes<class_@GlobalScope_method_var_to_bytes>`\ (\ variable\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`var_to_bytes_with_objects<class_@GlobalScope_method_var_to_bytes_with_objects>`\ (\ variable\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`var_to_str<class_@GlobalScope_method_var_to_str>`\ (\ variable\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`weakref<class_@GlobalScope_method_weakref>`\ (\ obj\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`wrap<class_@GlobalScope_method_wrap>`\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`wrapf<class_@GlobalScope_method_wrapf>`\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`wrapi<class_@GlobalScope_method_wrapi>`\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) |
+-------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_@GlobalScope_Side:
.. rst-class:: classref-enumeration
enum **Side**: :ref:`🔗<enum_@GlobalScope_Side>`
.. _class_@GlobalScope_constant_SIDE_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Side<enum_@GlobalScope_Side>` **SIDE_LEFT** = ``0``
Lado izquierdo, generalmente utilizado para clases derivadas de :ref:`Control<class_Control>` o :ref:`StyleBox<class_StyleBox>`.
.. _class_@GlobalScope_constant_SIDE_TOP:
.. rst-class:: classref-enumeration-constant
:ref:`Side<enum_@GlobalScope_Side>` **SIDE_TOP** = ``1``
Lado superior, generalmente utilizado para clases derivadas de :ref:`Control<class_Control>` o :ref:`StyleBox<class_StyleBox>`.
.. _class_@GlobalScope_constant_SIDE_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Side<enum_@GlobalScope_Side>` **SIDE_RIGHT** = ``2``
Lado derecho, generalmente utilizado para clases derivadas de :ref:`Control<class_Control>` o :ref:`StyleBox<class_StyleBox>`.
.. _class_@GlobalScope_constant_SIDE_BOTTOM:
.. rst-class:: classref-enumeration-constant
:ref:`Side<enum_@GlobalScope_Side>` **SIDE_BOTTOM** = ``3``
Lado inferior, generalmente utilizado para clases derivadas de :ref:`Control<class_Control>` o :ref:`StyleBox<class_StyleBox>`.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Corner:
.. rst-class:: classref-enumeration
enum **Corner**: :ref:`🔗<enum_@GlobalScope_Corner>`
.. _class_@GlobalScope_constant_CORNER_TOP_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_TOP_LEFT** = ``0``
Esquina Superior Izquierda.
.. _class_@GlobalScope_constant_CORNER_TOP_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_TOP_RIGHT** = ``1``
Esquina Superior Derecha.
.. _class_@GlobalScope_constant_CORNER_BOTTOM_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_BOTTOM_RIGHT** = ``2``
Esquina Inferior Derecha.
.. _class_@GlobalScope_constant_CORNER_BOTTOM_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Corner<enum_@GlobalScope_Corner>` **CORNER_BOTTOM_LEFT** = ``3``
Esquina Inferior Izquierda.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Orientation:
.. rst-class:: classref-enumeration
enum **Orientation**: :ref:`🔗<enum_@GlobalScope_Orientation>`
.. _class_@GlobalScope_constant_VERTICAL:
.. rst-class:: classref-enumeration-constant
:ref:`Orientation<enum_@GlobalScope_Orientation>` **VERTICAL** = ``1``
Alineación vertical general, generalmente usada para :ref:`Separator<class_Separator>`, :ref:`ScrollBar<class_ScrollBar>`, :ref:`Slider<class_Slider>`, etc.
.. _class_@GlobalScope_constant_HORIZONTAL:
.. rst-class:: classref-enumeration-constant
:ref:`Orientation<enum_@GlobalScope_Orientation>` **HORIZONTAL** = ``0``
Alineación horizontal general, generalmente usada para :ref:`Separator<class_Separator>`, :ref:`ScrollBar<class_ScrollBar>`, :ref:`Slider<class_Slider>`, etc.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_ClockDirection:
.. rst-class:: classref-enumeration
enum **ClockDirection**: :ref:`🔗<enum_@GlobalScope_ClockDirection>`
.. _class_@GlobalScope_constant_CLOCKWISE:
.. rst-class:: classref-enumeration-constant
:ref:`ClockDirection<enum_@GlobalScope_ClockDirection>` **CLOCKWISE** = ``0``
Rotación en el sentido de las agujas del reloj. Utilizado por algunos métodos (p.ej., :ref:`Image.rotate_90()<class_Image_method_rotate_90>`).
.. _class_@GlobalScope_constant_COUNTERCLOCKWISE:
.. rst-class:: classref-enumeration-constant
:ref:`ClockDirection<enum_@GlobalScope_ClockDirection>` **COUNTERCLOCKWISE** = ``1``
Rotación en sentido contrario a las agujas del reloj. Utilizado por algunos métodos (p.ej. :ref:`Image.rotate_90()<class_Image_method_rotate_90>`).
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_HorizontalAlignment:
.. rst-class:: classref-enumeration
enum **HorizontalAlignment**: :ref:`🔗<enum_@GlobalScope_HorizontalAlignment>`
.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_LEFT** = ``0``
Alineación horizontal izquierda, generalmente para clases de texto.
.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_CENTER** = ``1``
Alineación central horizontal, generalmente para clases de texto.
.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_RIGHT** = ``2``
Alineación horizontal derecha, generalmente para clases de texto.
.. _class_@GlobalScope_constant_HORIZONTAL_ALIGNMENT_FILL:
.. rst-class:: classref-enumeration-constant
:ref:`HorizontalAlignment<enum_@GlobalScope_HorizontalAlignment>` **HORIZONTAL_ALIGNMENT_FILL** = ``3``
Expandir fila para ajustar el ancho, generalmente para clases derivadas de texto.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_VerticalAlignment:
.. rst-class:: classref-enumeration
enum **VerticalAlignment**: :ref:`🔗<enum_@GlobalScope_VerticalAlignment>`
.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_TOP:
.. rst-class:: classref-enumeration-constant
:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_TOP** = ``0``
Alineación vertical superior, generalmente para clases de texto.
.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_CENTER** = ``1``
Alineación central vertical, normalmente para clases de texto.Alineacion central vertical, generalmente usada para clases derivadas de texto.
.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_BOTTOM:
.. rst-class:: classref-enumeration-constant
:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_BOTTOM** = ``2``
Alineación vertical inferior, generalmente para clases de texto.
.. _class_@GlobalScope_constant_VERTICAL_ALIGNMENT_FILL:
.. rst-class:: classref-enumeration-constant
:ref:`VerticalAlignment<enum_@GlobalScope_VerticalAlignment>` **VERTICAL_ALIGNMENT_FILL** = ``3``
Expandir filas para ajustar la altura, generalmente para clases derivadas de texto.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_InlineAlignment:
.. rst-class:: classref-enumeration
enum **InlineAlignment**: :ref:`🔗<enum_@GlobalScope_InlineAlignment>`
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TOP_TO:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TOP_TO** = ``0``
Alinea la parte superior del objeto en línea (por ejemplo, imagen, tabla) a la posición del texto especificada por la constante ``INLINE_ALIGNMENT_TO_*``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_CENTER_TO:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_CENTER_TO** = ``1``
Alinea la parte superior del objeto en línea (por ejemplo, imagen, tabla) a la posición del texto especificada por la constante ``INLINE_ALIGNMENT_TO_*``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BASELINE_TO:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BASELINE_TO** = ``3``
Alinea la línea base (definida por el usuario) del objeto en línea (por ejemplo, imagen, tabla) con la posición del texto especificado por la constante ``INLINE_ALIGNMENT_TO_*``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BOTTOM_TO:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BOTTOM_TO** = ``2``
Alinea la parte inferior del objeto en línea (por ejemplo, imagen, tabla) con la posición del texto especificado por la constante ``INLINE_ALIGNMENT_TO_*``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_TOP:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_TOP** = ``0``
Alinea la posición del objeto en línea (por ejemplo, imagen, tabla) especificado por la constante ``INLINE_ALIGNMENT_*_TO`` en la parte superior del texto.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_CENTER** = ``4``
Alinea la posición del objeto en línea (por ejemplo, imagen, tabla) especificado por la constante ``INLINE_ALIGNMENT_*_TO`` al centro del texto.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_BASELINE:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_BASELINE** = ``8``
Alinea la posición del objeto en línea (por ejemplo, imagen, tabla) especificado por la constante ``INLINE_ALIGNMENT_*_TO`` con la línea base del texto.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TO_BOTTOM:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TO_BOTTOM** = ``12``
Alinea el objeto en línea (por ejemplo, imagen, tabla) en la parte inferior del texto.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TOP:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TOP** = ``0``
Alinea la parte superior del objeto en línea (p. ej., imagen, tabla) con la parte superior del texto. Equivalente a ``INLINE_ALIGNMENT_TOP_TO | INLINE_ALIGNMENT_TO_TOP``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_CENTER:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_CENTER** = ``5``
Alinea el centro del objeto en línea (p. ej., imagen, tabla) con el centro del texto. Equivalente a ``INLINE_ALIGNMENT_CENTER_TO | INLINE_ALIGNMENT_TO_CENTER``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_BOTTOM:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_BOTTOM** = ``14``
Alinea la parte inferior del objeto en línea (p. ej., imagen, tabla) con la parte inferior del texto. Equivalente a ``INLINE_ALIGNMENT_BOTTOM_TO | INLINE_ALIGNMENT_TO_BOTTOM``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_IMAGE_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_IMAGE_MASK** = ``3``
Una máscara de bits para las constantes de alineación de ``INLINE_ALIGNMENT_*_TO``.
.. _class_@GlobalScope_constant_INLINE_ALIGNMENT_TEXT_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`InlineAlignment<enum_@GlobalScope_InlineAlignment>` **INLINE_ALIGNMENT_TEXT_MASK** = ``12``
Una máscara de bits para las constantes de alineación de ``INLINE_ALIGNMENT_TO_*``.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_EulerOrder:
.. rst-class:: classref-enumeration
enum **EulerOrder**: :ref:`🔗<enum_@GlobalScope_EulerOrder>`
.. _class_@GlobalScope_constant_EULER_ORDER_XYZ:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_XYZ** = ``0``
Especifica que los ángulos de Euler deben estar en orden XYZ. Al componer, el orden es X, Y, Z. Al descomponer, el orden se invierte: primero Z, luego Y y, por último, X.
.. _class_@GlobalScope_constant_EULER_ORDER_XZY:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_XZY** = ``1``
Especifica que los ángulos de Euler deben estar en orden XZY. Al componer, el orden es X, Z, Y. Al descomponer, el orden se invierte: primero Y, luego Z y, por último, X.
.. _class_@GlobalScope_constant_EULER_ORDER_YXZ:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_YXZ** = ``2``
Especifica que los ángulos de Euler deben estar en orden YXZ. Al componer, el orden es Y, X, Z. Al descomponer, el orden se invierte: primero Z, luego X y, por último, Y.
.. _class_@GlobalScope_constant_EULER_ORDER_YZX:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_YZX** = ``3``
Especifica que los ángulos de Euler deben estar en orden YZX. Al componer, el orden es Y, Z, X. Al descomponer, el orden se invierte: primero X, luego Z y, por último, Y.
.. _class_@GlobalScope_constant_EULER_ORDER_ZXY:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_ZXY** = ``4``
Especifica que los ángulos de Euler deben estar en orden ZXY. Al componer, el orden es Z, X, Y. Al descomponer, el orden se invierte: primero Y, luego X y, por último, Z.
.. _class_@GlobalScope_constant_EULER_ORDER_ZYX:
.. rst-class:: classref-enumeration-constant
:ref:`EulerOrder<enum_@GlobalScope_EulerOrder>` **EULER_ORDER_ZYX** = ``5``
Especifica que los ángulos de Euler deben estar en orden ZYX. Al componer, el orden es Z, Y, X. Al descomponer, el orden se invierte: primero X, luego Y y, por último, Z.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Key:
.. rst-class:: classref-enumeration
enum **Key**: :ref:`🔗<enum_@GlobalScope_Key>`
.. _class_@GlobalScope_constant_KEY_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_NONE** = ``0``
Valor de enum que no corresponde a ninguna clave. Se utiliza para inicializar las propiedades :ref:`Key<enum_@GlobalScope_Key>` con un estado genérico.
.. _class_@GlobalScope_constant_KEY_SPECIAL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SPECIAL** = ``4194304``
Los códigos clave con este bit aplicado no son imprimibles.
.. _class_@GlobalScope_constant_KEY_ESCAPE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ESCAPE** = ``4194305``
Tecla Escape.
.. _class_@GlobalScope_constant_KEY_TAB:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_TAB** = ``4194306``
Tecla Tabulador.
.. _class_@GlobalScope_constant_KEY_BACKTAB:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKTAB** = ``4194307``
Tecla Shift + Tab.
.. _class_@GlobalScope_constant_KEY_BACKSPACE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKSPACE** = ``4194308``
Tecla Retroceso.
.. _class_@GlobalScope_constant_KEY_ENTER:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ENTER** = ``4194309``
Devuelve la tecla (en el teclado principal).
.. _class_@GlobalScope_constant_KEY_KP_ENTER:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_ENTER** = ``4194310``
Pulsa la tecla en el teclado numerico.
.. _class_@GlobalScope_constant_KEY_INSERT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_INSERT** = ``4194311``
Tecla Insertar.
.. _class_@GlobalScope_constant_KEY_DELETE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_DELETE** = ``4194312``
Tecla Suprimir.
.. _class_@GlobalScope_constant_KEY_PAUSE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAUSE** = ``4194313``
Tecla Pausa.
.. _class_@GlobalScope_constant_KEY_PRINT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PRINT** = ``4194314``
Tecla Imprimir Pantalla.
.. _class_@GlobalScope_constant_KEY_SYSREQ:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SYSREQ** = ``4194315``
Tecla Peticion de Sistema.
.. _class_@GlobalScope_constant_KEY_CLEAR:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_CLEAR** = ``4194316``
Tecla Clear.
.. _class_@GlobalScope_constant_KEY_HOME:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_HOME** = ``4194317``
Tecla Inicio.
.. _class_@GlobalScope_constant_KEY_END:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_END** = ``4194318``
Tecla Fin.
.. _class_@GlobalScope_constant_KEY_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LEFT** = ``4194319``
Tecla Flecha Izquierda.
.. _class_@GlobalScope_constant_KEY_UP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_UP** = ``4194320``
Tecla Flecha Arriba.
.. _class_@GlobalScope_constant_KEY_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_RIGHT** = ``4194321``
Tecla flecha derecha.
.. _class_@GlobalScope_constant_KEY_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_DOWN** = ``4194322``
Tecla Flecha abajo.
.. _class_@GlobalScope_constant_KEY_PAGEUP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAGEUP** = ``4194323``
Tecla RePag.
.. _class_@GlobalScope_constant_KEY_PAGEDOWN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PAGEDOWN** = ``4194324``
Tecla AvPag.
.. _class_@GlobalScope_constant_KEY_SHIFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SHIFT** = ``4194325``
Tecla Shift.
.. _class_@GlobalScope_constant_KEY_CTRL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_CTRL** = ``4194326``
Tecla Control.
.. _class_@GlobalScope_constant_KEY_META:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_META** = ``4194327``
Tecla Meta.
.. _class_@GlobalScope_constant_KEY_ALT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ALT** = ``4194328``
Tecla Alt.
.. _class_@GlobalScope_constant_KEY_CAPSLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_CAPSLOCK** = ``4194329``
Tecla Bloque Mayusculas.
.. _class_@GlobalScope_constant_KEY_NUMLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_NUMLOCK** = ``4194330``
Tecla Bloque numerico.
.. _class_@GlobalScope_constant_KEY_SCROLLLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SCROLLLOCK** = ``4194331``
Tecla Bloqueo Scroll.
.. _class_@GlobalScope_constant_KEY_F1:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F1** = ``4194332``
Tecla F1.
.. _class_@GlobalScope_constant_KEY_F2:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F2** = ``4194333``
Tecla F2.
.. _class_@GlobalScope_constant_KEY_F3:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F3** = ``4194334``
Tecla F3.
.. _class_@GlobalScope_constant_KEY_F4:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F4** = ``4194335``
Tecla F4.
.. _class_@GlobalScope_constant_KEY_F5:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F5** = ``4194336``
Tecla F5.
.. _class_@GlobalScope_constant_KEY_F6:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F6** = ``4194337``
Tecla F6.
.. _class_@GlobalScope_constant_KEY_F7:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F7** = ``4194338``
Tecla F7.
.. _class_@GlobalScope_constant_KEY_F8:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F8** = ``4194339``
Tecla F8.
.. _class_@GlobalScope_constant_KEY_F9:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F9** = ``4194340``
Tecla F9.
.. _class_@GlobalScope_constant_KEY_F10:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F10** = ``4194341``
Tecla F10.
.. _class_@GlobalScope_constant_KEY_F11:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F11** = ``4194342``
Tecla F11.
.. _class_@GlobalScope_constant_KEY_F12:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F12** = ``4194343``
Tecla F12.
.. _class_@GlobalScope_constant_KEY_F13:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F13** = ``4194344``
Tecla F13.
.. _class_@GlobalScope_constant_KEY_F14:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F14** = ``4194345``
Tecla F14.
.. _class_@GlobalScope_constant_KEY_F15:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F15** = ``4194346``
Tecla F15.
.. _class_@GlobalScope_constant_KEY_F16:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F16** = ``4194347``
Tecla F16.
.. _class_@GlobalScope_constant_KEY_F17:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F17** = ``4194348``
Tecla F17.
.. _class_@GlobalScope_constant_KEY_F18:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F18** = ``4194349``
Tecla F18.
.. _class_@GlobalScope_constant_KEY_F19:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F19** = ``4194350``
Tecla F19.
.. _class_@GlobalScope_constant_KEY_F20:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F20** = ``4194351``
Tecla F20.
.. _class_@GlobalScope_constant_KEY_F21:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F21** = ``4194352``
Tecla F21.
.. _class_@GlobalScope_constant_KEY_F22:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F22** = ``4194353``
Tecla F22.
.. _class_@GlobalScope_constant_KEY_F23:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F23** = ``4194354``
Tecla F23.
.. _class_@GlobalScope_constant_KEY_F24:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F24** = ``4194355``
Tecla F24.
.. _class_@GlobalScope_constant_KEY_F25:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F25** = ``4194356``
Tecla F25. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F26:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F26** = ``4194357``
Tecla F26. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F27:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F27** = ``4194358``
Tecla F27. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F28:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F28** = ``4194359``
Tecla F28. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F29:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F29** = ``4194360``
Tecla F29. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F30:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F30** = ``4194361``
Tecla F30. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F31:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F31** = ``4194362``
Tecla F31. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F32:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F32** = ``4194363``
Tecla F32. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F33:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F33** = ``4194364``
Tecla F33. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F34:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F34** = ``4194365``
Tecla F34. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_F35:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F35** = ``4194366``
Tecla F35. Solo soportada en macOS y Linux por las limitaciones de Windows.
.. _class_@GlobalScope_constant_KEY_KP_MULTIPLY:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_MULTIPLY** = ``4194433``
Tecla Multiplicar(\*) del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_DIVIDE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_DIVIDE** = ``4194434``
Tecla Division(/) del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_SUBTRACT** = ``4194435``
Tecla Resta(-) del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_PERIOD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_PERIOD** = ``4194436``
Tecla . decimal(.) del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_ADD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_ADD** = ``4194437``
Tecla Suma(+) del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_0:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_0** = ``4194438``
Tecla 0 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_1:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_1** = ``4194439``
Tecla 1 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_2:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_2** = ``4194440``
Tecla 2 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_3:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_3** = ``4194441``
Tecla 3 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_4:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_4** = ``4194442``
Tecla 4 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_5:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_5** = ``4194443``
Tecla 5 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_6:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_6** = ``4194444``
Tecla 6 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_7:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_7** = ``4194445``
Tecla 7 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_8:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_8** = ``4194446``
Tecla 8 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_KP_9:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KP_9** = ``4194447``
Tecla 9 del teclado numérico.
.. _class_@GlobalScope_constant_KEY_MENU:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MENU** = ``4194370``
Tecla Menu Contexto.
.. _class_@GlobalScope_constant_KEY_HYPER:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_HYPER** = ``4194371``
Tecla Hyper. (En Linux/X11 solo).
.. _class_@GlobalScope_constant_KEY_HELP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_HELP** = ``4194373``
Tecla Ayuda.
.. _class_@GlobalScope_constant_KEY_BACK:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACK** = ``4194376``
Tecla de Retroceso.
.. _class_@GlobalScope_constant_KEY_FORWARD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_FORWARD** = ``4194377``
Tecla de Adelante.
.. _class_@GlobalScope_constant_KEY_STOP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_STOP** = ``4194378``
Tecla reproduccion parar.
.. _class_@GlobalScope_constant_KEY_REFRESH:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_REFRESH** = ``4194379``
Tecla de Recarga.
.. _class_@GlobalScope_constant_KEY_VOLUMEDOWN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEDOWN** = ``4194380``
Tecla Bajar Volumen.
.. _class_@GlobalScope_constant_KEY_VOLUMEMUTE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEMUTE** = ``4194381``
Tecla Quitar Volumen.
.. _class_@GlobalScope_constant_KEY_VOLUMEUP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_VOLUMEUP** = ``4194382``
Tecla Subir Volumen.
.. _class_@GlobalScope_constant_KEY_MEDIAPLAY:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIAPLAY** = ``4194388``
Tecla de reproducción multimedia.
.. _class_@GlobalScope_constant_KEY_MEDIASTOP:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIASTOP** = ``4194389``
Tecla reproduccion parar.
.. _class_@GlobalScope_constant_KEY_MEDIAPREVIOUS:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIAPREVIOUS** = ``4194390``
Tecla de Canción previa.
.. _class_@GlobalScope_constant_KEY_MEDIANEXT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIANEXT** = ``4194391``
Tecla de Siguiente canción.
.. _class_@GlobalScope_constant_KEY_MEDIARECORD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MEDIARECORD** = ``4194392``
Tecla grabar.
.. _class_@GlobalScope_constant_KEY_HOMEPAGE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_HOMEPAGE** = ``4194393``
Tecla Inicio.
.. _class_@GlobalScope_constant_KEY_FAVORITES:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_FAVORITES** = ``4194394``
Tecla Favoritos.
.. _class_@GlobalScope_constant_KEY_SEARCH:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SEARCH** = ``4194395``
Tecla Buscar.
.. _class_@GlobalScope_constant_KEY_STANDBY:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_STANDBY** = ``4194396``
Tecla en espera(Standby).
.. _class_@GlobalScope_constant_KEY_OPENURL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_OPENURL** = ``4194397``
Tecla Abrir URL/Abrir el navegador.
.. _class_@GlobalScope_constant_KEY_LAUNCHMAIL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHMAIL** = ``4194398``
Tecla Abrir el Correo.
.. _class_@GlobalScope_constant_KEY_LAUNCHMEDIA:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHMEDIA** = ``4194399``
Tecla lanzar Media.
.. _class_@GlobalScope_constant_KEY_LAUNCH0:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH0** = ``4194400``
Tecla Acceso Directo 0.
.. _class_@GlobalScope_constant_KEY_LAUNCH1:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH1** = ``4194401``
Tecla Acceso Directo 1.
.. _class_@GlobalScope_constant_KEY_LAUNCH2:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH2** = ``4194402``
Tecla Acceso Directo 2.
.. _class_@GlobalScope_constant_KEY_LAUNCH3:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH3** = ``4194403``
Tecla Acceso Directo 3.
.. _class_@GlobalScope_constant_KEY_LAUNCH4:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH4** = ``4194404``
Tecla Acceso Directo 4.
.. _class_@GlobalScope_constant_KEY_LAUNCH5:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH5** = ``4194405``
Tecla Acceso Directo 5.
.. _class_@GlobalScope_constant_KEY_LAUNCH6:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH6** = ``4194406``
Tecla Acceso Directo 6.
.. _class_@GlobalScope_constant_KEY_LAUNCH7:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH7** = ``4194407``
Tecla Acceso Directo 7.
.. _class_@GlobalScope_constant_KEY_LAUNCH8:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH8** = ``4194408``
Tecla Acceso Directo 8.
.. _class_@GlobalScope_constant_KEY_LAUNCH9:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCH9** = ``4194409``
Tecla Acceso Directo 9.
.. _class_@GlobalScope_constant_KEY_LAUNCHA:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHA** = ``4194410``
Tecla Acceso Directo A.
.. _class_@GlobalScope_constant_KEY_LAUNCHB:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHB** = ``4194411``
Tecla Acceso Directo B.
.. _class_@GlobalScope_constant_KEY_LAUNCHC:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHC** = ``4194412``
Tecla Acceso Directo C.
.. _class_@GlobalScope_constant_KEY_LAUNCHD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHD** = ``4194413``
Tecla Acceso Directo D.
.. _class_@GlobalScope_constant_KEY_LAUNCHE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHE** = ``4194414``
Tecla Acceso Directo E.
.. _class_@GlobalScope_constant_KEY_LAUNCHF:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LAUNCHF** = ``4194415``
Tecla Acceso Directo F.
.. _class_@GlobalScope_constant_KEY_GLOBE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_GLOBE** = ``4194416``
Tecla "Globo" en el teclado de Mac / iPad.
.. _class_@GlobalScope_constant_KEY_KEYBOARD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_KEYBOARD** = ``4194417``
Tecla "Teclado en pantalla" en el teclado del iPad.
.. _class_@GlobalScope_constant_KEY_JIS_EISU:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_JIS_EISU** = ``4194418``
Tecla 英数 en el teclado de Mac.
.. _class_@GlobalScope_constant_KEY_JIS_KANA:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_JIS_KANA** = ``4194419``
Tecla かな en el teclado de Mac.
.. _class_@GlobalScope_constant_KEY_UNKNOWN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_UNKNOWN** = ``8388607``
Tecla desconocida.
.. _class_@GlobalScope_constant_KEY_SPACE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SPACE** = ``32``
Tecla Espaciado.
.. _class_@GlobalScope_constant_KEY_EXCLAM:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_EXCLAM** = ``33``
Tecla de signo de exclamación (``!``).
.. _class_@GlobalScope_constant_KEY_QUOTEDBL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUOTEDBL** = ``34``
Tecla de comillas dobles (``"``).
.. _class_@GlobalScope_constant_KEY_NUMBERSIGN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_NUMBERSIGN** = ``35``
Tecla de signo numérico o *gato* (``#``).
.. _class_@GlobalScope_constant_KEY_DOLLAR:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_DOLLAR** = ``36``
Tecla de signo de dólar (``$``).
.. _class_@GlobalScope_constant_KEY_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PERCENT** = ``37``
Tecla de signo de porcentaje (``%``).
.. _class_@GlobalScope_constant_KEY_AMPERSAND:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_AMPERSAND** = ``38``
Tecla de et (``&``).
.. _class_@GlobalScope_constant_KEY_APOSTROPHE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_APOSTROPHE** = ``39``
Tecla de apóstrofe (``'``).
.. _class_@GlobalScope_constant_KEY_PARENLEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PARENLEFT** = ``40``
Tecla de paréntesis izquierdo (``(``).
.. _class_@GlobalScope_constant_KEY_PARENRIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PARENRIGHT** = ``41``
Tecla de paréntesis derecho (``)``).
.. _class_@GlobalScope_constant_KEY_ASTERISK:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASTERISK** = ``42``
Tecla de asterisco (``*``).
.. _class_@GlobalScope_constant_KEY_PLUS:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PLUS** = ``43``
Tecla de más (``+``).
.. _class_@GlobalScope_constant_KEY_COMMA:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_COMMA** = ``44``
Tecla de coma (``,``).
.. _class_@GlobalScope_constant_KEY_MINUS:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_MINUS** = ``45``
Tecla de menos (``-``).
.. _class_@GlobalScope_constant_KEY_PERIOD:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_PERIOD** = ``46``
Tecla de punto (``.``).
.. _class_@GlobalScope_constant_KEY_SLASH:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SLASH** = ``47``
Tecla de diagonal (``/``).
.. _class_@GlobalScope_constant_KEY_0:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_0** = ``48``
Techa numérica 0.
.. _class_@GlobalScope_constant_KEY_1:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_1** = ``49``
Techa numérica 1.
.. _class_@GlobalScope_constant_KEY_2:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_2** = ``50``
Techa numérica 2.
.. _class_@GlobalScope_constant_KEY_3:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_3** = ``51``
Techa numérica 3.
.. _class_@GlobalScope_constant_KEY_4:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_4** = ``52``
Techa numérica 4.
.. _class_@GlobalScope_constant_KEY_5:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_5** = ``53``
Techa numérica 5.
.. _class_@GlobalScope_constant_KEY_6:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_6** = ``54``
Techa numérica 6.
.. _class_@GlobalScope_constant_KEY_7:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_7** = ``55``
Techa numérica 7.
.. _class_@GlobalScope_constant_KEY_8:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_8** = ``56``
Techa numérica 8.
.. _class_@GlobalScope_constant_KEY_9:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_9** = ``57``
Techa numérica 9.
.. _class_@GlobalScope_constant_KEY_COLON:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_COLON** = ``58``
Tecla de dos puntos (``:``).
.. _class_@GlobalScope_constant_KEY_SEMICOLON:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SEMICOLON** = ``59``
Tecla de punto y coma (``;``).
.. _class_@GlobalScope_constant_KEY_LESS:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_LESS** = ``60``
Tecla menor que (``<``).
.. _class_@GlobalScope_constant_KEY_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_EQUAL** = ``61``
Signo de igualdad (``==``).
.. _class_@GlobalScope_constant_KEY_GREATER:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_GREATER** = ``62``
Tecla mayor que (``>``).
.. _class_@GlobalScope_constant_KEY_QUESTION:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUESTION** = ``63``
Tecla de signo de interrogación (``?``).
.. _class_@GlobalScope_constant_KEY_AT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_AT** = ``64``
Tecla de signo arroba (``@``).
.. _class_@GlobalScope_constant_KEY_A:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_A** = ``65``
Tecla A.
.. _class_@GlobalScope_constant_KEY_B:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_B** = ``66``
Tecla B.
.. _class_@GlobalScope_constant_KEY_C:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_C** = ``67``
Tecla C.
.. _class_@GlobalScope_constant_KEY_D:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_D** = ``68``
Tecla D.
.. _class_@GlobalScope_constant_KEY_E:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_E** = ``69``
Tecla E.
.. _class_@GlobalScope_constant_KEY_F:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_F** = ``70``
Tecla F.
.. _class_@GlobalScope_constant_KEY_G:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_G** = ``71``
Tecla G.
.. _class_@GlobalScope_constant_KEY_H:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_H** = ``72``
Tecla H.
.. _class_@GlobalScope_constant_KEY_I:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_I** = ``73``
Tecla I.
.. _class_@GlobalScope_constant_KEY_J:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_J** = ``74``
Tecla J.
.. _class_@GlobalScope_constant_KEY_K:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_K** = ``75``
Tecla K.
.. _class_@GlobalScope_constant_KEY_L:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_L** = ``76``
Tecla L.
.. _class_@GlobalScope_constant_KEY_M:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_M** = ``77``
Tecla M.
.. _class_@GlobalScope_constant_KEY_N:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_N** = ``78``
Tecla N.
.. _class_@GlobalScope_constant_KEY_O:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_O** = ``79``
Tecla O.
.. _class_@GlobalScope_constant_KEY_P:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_P** = ``80``
Tecla P.
.. _class_@GlobalScope_constant_KEY_Q:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_Q** = ``81``
Tecla Q.
.. _class_@GlobalScope_constant_KEY_R:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_R** = ``82``
Tecla R.
.. _class_@GlobalScope_constant_KEY_S:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_S** = ``83``
Tecla S.
.. _class_@GlobalScope_constant_KEY_T:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_T** = ``84``
Tecla T.
.. _class_@GlobalScope_constant_KEY_U:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_U** = ``85``
Tecla U.
.. _class_@GlobalScope_constant_KEY_V:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_V** = ``86``
Tecla V.
.. _class_@GlobalScope_constant_KEY_W:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_W** = ``87``
Tecla W.
.. _class_@GlobalScope_constant_KEY_X:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_X** = ``88``
Tecla X.
.. _class_@GlobalScope_constant_KEY_Y:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_Y** = ``89``
Tecla Y.
.. _class_@GlobalScope_constant_KEY_Z:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_Z** = ``90``
Tecla Z.
.. _class_@GlobalScope_constant_KEY_BRACKETLEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACKETLEFT** = ``91``
Tecla de corchete izquierdo (``[lb]``).
.. _class_@GlobalScope_constant_KEY_BACKSLASH:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BACKSLASH** = ``92``
Tecla de diagonal invertida (``\``).
.. _class_@GlobalScope_constant_KEY_BRACKETRIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACKETRIGHT** = ``93``
Tecla de corchete derecho (``[rb]``).
.. _class_@GlobalScope_constant_KEY_ASCIICIRCUM:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASCIICIRCUM** = ``94``
Tecla de circunflejo (``^``).
.. _class_@GlobalScope_constant_KEY_UNDERSCORE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_UNDERSCORE** = ``95``
Tecla de guión bajo (``_``).
.. _class_@GlobalScope_constant_KEY_QUOTELEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_QUOTELEFT** = ``96``
Tecla de acento grave (`````).
.. _class_@GlobalScope_constant_KEY_BRACELEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACELEFT** = ``123``
Tecla de llave izquierda (``{``).
.. _class_@GlobalScope_constant_KEY_BAR:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BAR** = ``124``
Tecla de barra vertical o *pipe* (``|``).
.. _class_@GlobalScope_constant_KEY_BRACERIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_BRACERIGHT** = ``125``
Tecla de llave derecha (``}``).
.. _class_@GlobalScope_constant_KEY_ASCIITILDE:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_ASCIITILDE** = ``126``
Tecla de virgulilla (``~``).
.. _class_@GlobalScope_constant_KEY_YEN:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_YEN** = ``165``
Tecla de símbolo del yen (``¥``).
.. _class_@GlobalScope_constant_KEY_SECTION:
.. rst-class:: classref-enumeration-constant
:ref:`Key<enum_@GlobalScope_Key>` **KEY_SECTION** = ``167``
Signo de sección (``§``).
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_KeyModifierMask:
.. rst-class:: classref-enumeration
flags **KeyModifierMask**: :ref:`🔗<enum_@GlobalScope_KeyModifierMask>`
.. _class_@GlobalScope_constant_KEY_CODE_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_CODE_MASK** = ``8388607``
Máscara de código de tecla.
.. _class_@GlobalScope_constant_KEY_MODIFIER_MASK:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MODIFIER_MASK** = ``2130706432``
Máscara modificadora de tecla.
.. _class_@GlobalScope_constant_KEY_MASK_CMD_OR_CTRL:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CMD_OR_CTRL** = ``16777216``
Es automáticamente redirigido a :ref:`KEY_META<class_@GlobalScope_constant_KEY_META>` en macOS y a :ref:`KEY_CTRL<class_@GlobalScope_constant_KEY_CTRL>` en otras plataformas. Nunca se le da valor a la mascara en eventos reales y solo debe ser usada para redirecciones.
.. _class_@GlobalScope_constant_KEY_MASK_SHIFT:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_SHIFT** = ``33554432``
Máscara de la tecla Shift.
.. _class_@GlobalScope_constant_KEY_MASK_ALT:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_ALT** = ``67108864``
Máscara de la tecla Alt u Option (en macOS).
.. _class_@GlobalScope_constant_KEY_MASK_META:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_META** = ``134217728``
Máscara de la tecla Command (en macOS) o Meta/Windows.
.. _class_@GlobalScope_constant_KEY_MASK_CTRL:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_CTRL** = ``268435456``
Máscara de la tecla Control.
.. _class_@GlobalScope_constant_KEY_MASK_KPAD:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_KPAD** = ``536870912``
Keypad key mask.
.. _class_@GlobalScope_constant_KEY_MASK_GROUP_SWITCH:
.. rst-class:: classref-enumeration-constant
:ref:`KeyModifierMask<enum_@GlobalScope_KeyModifierMask>` **KEY_MASK_GROUP_SWITCH** = ``1073741824``
Máscara de la tecla de cambio de grupo.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_KeyLocation:
.. rst-class:: classref-enumeration
enum **KeyLocation**: :ref:`🔗<enum_@GlobalScope_KeyLocation>`
.. _class_@GlobalScope_constant_KEY_LOCATION_UNSPECIFIED:
.. rst-class:: classref-enumeration-constant
:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_UNSPECIFIED** = ``0``
Se usa para teclas que solo aparecen una vez (como 'A', 'B', 'C'...), o cuando no es necesario diferenciar entre la izquierda/``LEFT`` y la derecha/``RIGHT`` (Ctrl, Shift...).
Por ejemplo, al utilizar :ref:`InputEvent.is_match()<class_InputEvent_method_is_match>`, cualquier valor de :ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` capturará un evento con :ref:`KEY_LOCATION_UNSPECIFIED<class_@GlobalScope_constant_KEY_LOCATION_UNSPECIFIED>`.
.. _class_@GlobalScope_constant_KEY_LOCATION_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_LEFT** = ``1``
Una tecla que está a la izquierda de su gemela.
.. _class_@GlobalScope_constant_KEY_LOCATION_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`KeyLocation<enum_@GlobalScope_KeyLocation>` **KEY_LOCATION_RIGHT** = ``2``
Una tecla que está a la derecha de su idéntica.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_MouseButton:
.. rst-class:: classref-enumeration
enum **MouseButton**: :ref:`🔗<enum_@GlobalScope_MouseButton>`
.. _class_@GlobalScope_constant_MOUSE_BUTTON_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_NONE** = ``0``
Valor enum que no corresponde a ningún botón del ratón. Esto se utiliza para inicializar propiedades de tipo :ref:`MouseButton<enum_@GlobalScope_MouseButton>` con un valor genérico.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_LEFT** = ``1``
Botón principal del ratón, normalmente es el botón izquierdo.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_RIGHT** = ``2``
Botón secundario del ratón, normalmente es el botón derecho.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MIDDLE:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_MIDDLE** = ``3``
Botón central del ratón.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_UP:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_UP** = ``4``
Desplazamiento hacia arriba de la rueda del ratón.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_DOWN** = ``5``
Desplazamiento hacia abajo de la rueda del ratón.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_LEFT** = ``6``
Botón izquierdo de la rueda del ratón (sólo presente en algunos ratones).
.. _class_@GlobalScope_constant_MOUSE_BUTTON_WHEEL_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_WHEEL_RIGHT** = ``7``
Botón derecho de la rueda del ratón (sólo presente en algunos ratones).
.. _class_@GlobalScope_constant_MOUSE_BUTTON_XBUTTON1:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_XBUTTON1** = ``8``
Botón extra del ratón 1. Este botón a veces está presente, normalmente a los lados del ratón.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_XBUTTON2:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButton<enum_@GlobalScope_MouseButton>` **MOUSE_BUTTON_XBUTTON2** = ``9``
Botón extra del ratón 2. Este botón a veces está presente, normalmente a los lados del ratón.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_MouseButtonMask:
.. rst-class:: classref-enumeration
flags **MouseButtonMask**: :ref:`🔗<enum_@GlobalScope_MouseButtonMask>`
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_LEFT** = ``1``
Máscara para el botón principal del ratón, normalmente el izquierdo.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_RIGHT** = ``2``
Máscara para el botón secundario del ratón, normalmente el derecho.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MIDDLE:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MIDDLE** = ``4``
Máscara del botón central del ratón.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MB_XBUTTON1:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MB_XBUTTON1** = ``128``
Botón de ratón extra 1 máscara.
.. _class_@GlobalScope_constant_MOUSE_BUTTON_MASK_MB_XBUTTON2:
.. rst-class:: classref-enumeration-constant
:ref:`MouseButtonMask<enum_@GlobalScope_MouseButtonMask>` **MOUSE_BUTTON_MASK_MB_XBUTTON2** = ``256``
Máscara de botón de ratón extra 2.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_JoyButton:
.. rst-class:: classref-enumeration
enum **JoyButton**: :ref:`🔗<enum_@GlobalScope_JoyButton>`
.. _class_@GlobalScope_constant_JOY_BUTTON_INVALID:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_INVALID** = ``-1``
Un botón no válido del mando de juego.
.. _class_@GlobalScope_constant_JOY_BUTTON_A:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_A** = ``0``
Botón A de mando SDL. Corresponde al botón de abajo: X en Sony, A en Xbox, B en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_B:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_B** = ``1``
Botón B de mando SDL. Corresponde al botón de la derecha: 🞅 en Sony, B en Xbox, A en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_X:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_X** = ``2``
Botón X de mando SDL. Corresponde al botón de la izquierda: ◻ en Sony, X en Xbox, Y en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_Y** = ``3``
Botón Y de mando SDL. Corresponde al botón de arriba: △ en Sony, Y en Xbox, X en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_BACK:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_BACK** = ``4``
Botón "Back" (volver) de mando SDL. Corresponde al botón Select en Sony, Back en Xbox, - en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_GUIDE:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_GUIDE** = ``5``
Botón "Guide" de mando SDL. Corresponde al botón PS en Sony, Home en Xbox.
.. _class_@GlobalScope_constant_JOY_BUTTON_START:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_START** = ``6``
Botón start de mando SDL. Corresponde al botón Options en Sony, Menu en Xbox, + en Nintendo.
.. _class_@GlobalScope_constant_JOY_BUTTON_LEFT_STICK:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_LEFT_STICK** = ``7``
Botón del joystick izquierdo de mando SDL. Corresponde a L3 en Sony, L/LS en Xbox.
.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_STICK:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_STICK** = ``8``
Botón del joystick derecho de mando SDL. Corresponde a R3 en Sony, R/RS en Xbox.
.. _class_@GlobalScope_constant_JOY_BUTTON_LEFT_SHOULDER:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_LEFT_SHOULDER** = ``9``
Botón del gatillo izquierdo de mando SDL. Corresponde a L1 en Sony, LB en Xbox.
.. _class_@GlobalScope_constant_JOY_BUTTON_RIGHT_SHOULDER:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_RIGHT_SHOULDER** = ``10``
Botón del gatillo derecho de mando SDL. Corresponde a R1 en Sony, RB en Xbox.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_UP:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_UP** = ``11``
Botón de arriba del D-pad del mando.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_DOWN:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_DOWN** = ``12``
Botón de abajo del D-pad del mando.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_LEFT** = ``13``
Botón izquierdo del D-pad del mando.
.. _class_@GlobalScope_constant_JOY_BUTTON_DPAD_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_DPAD_RIGHT** = ``14``
Botón derecho del D-pad del mando.
.. _class_@GlobalScope_constant_JOY_BUTTON_MISC1:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_MISC1** = ``15``
Botón misceláneo de mando SDL. Corresponde a botón de compartir en Xbox, botón del micrófono en PS5, botón de captura en Nintendo Switch.
.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE1:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE1** = ``16``
Botón de paleta 1 del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE2:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE2** = ``17``
Botón de paleta 2 del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE3:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE3** = ``18``
Botón de paleta 3 del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_PADDLE4:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_PADDLE4** = ``19``
Botón de paleta 4 del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_TOUCHPAD:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_TOUCHPAD** = ``20``
Botón del panel táctil del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_SDL_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_SDL_MAX** = ``21``
El número de botones del mando SDL.
.. _class_@GlobalScope_constant_JOY_BUTTON_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JoyButton<enum_@GlobalScope_JoyButton>` **JOY_BUTTON_MAX** = ``128``
El número límite de botones de mando que el motor reconoce. El límite real podría ser menor dependiendo de la plataforma:
- **Android:** Hasta 36 botones.
- **Linux:** Hasta 80 botones.
- **Windows** and **macOS:** Hasta 128 botones.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_JoyAxis:
.. rst-class:: classref-enumeration
enum **JoyAxis**: :ref:`🔗<enum_@GlobalScope_JoyAxis>`
.. _class_@GlobalScope_constant_JOY_AXIS_INVALID:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_INVALID** = ``-1``
Un eje de mando no válido.
.. _class_@GlobalScope_constant_JOY_AXIS_LEFT_X:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_LEFT_X** = ``0``
Eje X del joystick izquierdo del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_LEFT_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_LEFT_Y** = ``1``
Eje Y del joystick izquierdo del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_X:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_X** = ``2``
Eje X del joystick derecho del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_RIGHT_Y:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_RIGHT_Y** = ``3``
Eje Y del joystick derecho del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_TRIGGER_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_TRIGGER_LEFT** = ``4``
Eje del gatillo izquierdo del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_TRIGGER_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_TRIGGER_RIGHT** = ``5``
Eje del gatillo derecho del mando.
.. _class_@GlobalScope_constant_JOY_AXIS_SDL_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_SDL_MAX** = ``6``
El número de ejes del mando SDL.
.. _class_@GlobalScope_constant_JOY_AXIS_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`JoyAxis<enum_@GlobalScope_JoyAxis>` **JOY_AXIS_MAX** = ``10``
El número límite de ejes del mando: en OpenVR se pueden usar hasta 5 Joysticks, siendo el total 10 ejes.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_MIDIMessage:
.. rst-class:: classref-enumeration
enum **MIDIMessage**: :ref:`🔗<enum_@GlobalScope_MIDIMessage>`
.. _class_@GlobalScope_constant_MIDI_MESSAGE_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NONE** = ``0``
No tiene ningún significado. Es el valor por defecto de :ref:`InputEventMIDI.message<class_InputEventMIDI_property_message>`.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_OFF:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NOTE_OFF** = ``8``
Mensaje MIDI enviado cuando se suelta una nota.
\ **Nota:** No todos los dispositivos MIDI envían este mensaje; algunos pueden enviar :ref:`MIDI_MESSAGE_NOTE_ON<class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_ON>` con :ref:`InputEventMIDI.velocity<class_InputEventMIDI_property_velocity>` establecido en ``0``.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_NOTE_ON:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_NOTE_ON** = ``9``
Mensaje MIDI enviado cuando se presiona una tecla.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_AFTERTOUCH:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_AFTERTOUCH** = ``10``
Mensaje MIDI enviado para indicar un cambio en la presión de una tecla pulsada, también conocido como aftertouch.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_CONTROL_CHANGE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CONTROL_CHANGE** = ``11``
Mensaje MIDI enviado cuando cambia el valor de un controlador. En un dispositivo MIDI, un controlador es cualquier entrada que no reproduce notas. Estos pueden incluir controles de volumen, balance y panorama, así como interruptores y pedales. Consulta la `especificación General MIDI <https://en.wikipedia.org/wiki/General_MIDI#Controller_events>`__ para obtener una lista breve.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_PROGRAM_CHANGE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_PROGRAM_CHANGE** = ``12``
Mensaje MIDI enviado cuando el dispositivo MIDI cambia su instrumento actual (también llamado *programa* o *ajuste predefinido*).
.. _class_@GlobalScope_constant_MIDI_MESSAGE_CHANNEL_PRESSURE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CHANNEL_PRESSURE** = ``13``
Mensaje MIDI enviado para indicar un cambio de presión en todo el canal. Algunos dispositivos MIDI pueden enviar esto en lugar de :ref:`MIDI_MESSAGE_AFTERTOUCH<class_@GlobalScope_constant_MIDI_MESSAGE_AFTERTOUCH>`.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_PITCH_BEND:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_PITCH_BEND** = ``14``
Mensaje MIDI enviado cuando cambia el valor del pitch bender, generalmente una rueda en el dispositivo MIDI.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_SYSTEM_EXCLUSIVE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SYSTEM_EXCLUSIVE** = ``240``
Mensaje exclusivo del sistema MIDI (SysEx). Este tipo de mensaje no está estandarizado y depende en gran medida del dispositivo MIDI que lo envía.
\ **Nota:** No se ha implementado la obtención de los datos de este mensaje desde :ref:`InputEventMIDI<class_InputEventMIDI>`.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_QUARTER_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_QUARTER_FRAME** = ``241``
Mensaje MIDI enviado cada cuarto de fotograma para mantener sincronizados los dispositivos MIDI conectados. Relacionado con :ref:`MIDI_MESSAGE_TIMING_CLOCK<class_@GlobalScope_constant_MIDI_MESSAGE_TIMING_CLOCK>`.
\ **Nota:** No se ha implementado la obtención de los datos de este mensaje desde :ref:`InputEventMIDI<class_InputEventMIDI>`.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_SONG_POSITION_POINTER:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SONG_POSITION_POINTER** = ``242``
Mensaje MIDI enviado para saltar a una nueva posición en la secuencia o canción actual.
\ **Nota:** No se ha implementado la obtención de los datos de este mensaje desde :ref:`InputEventMIDI<class_InputEventMIDI>`.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_SONG_SELECT:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SONG_SELECT** = ``243``
Mensaje MIDI enviado para seleccionar una secuencia o canción para reproducir.
\ **Nota:** La obtención de los datos de este mensaje de :ref:`InputEventMIDI<class_InputEventMIDI>` no está implementada.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_TUNE_REQUEST:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_TUNE_REQUEST** = ``246``
Mensaje MIDI enviado para solicitar una calibración de afinación. Se utiliza en sintetizadores analógicos. La mayoría de los dispositivos MIDI modernos no requieren este mensaje.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_TIMING_CLOCK:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_TIMING_CLOCK** = ``248``
Mensaje MIDI enviado 24 veces después de :ref:`MIDI_MESSAGE_QUARTER_FRAME<class_@GlobalScope_constant_MIDI_MESSAGE_QUARTER_FRAME>`, para mantener sincronizados los dispositivos MIDI conectados.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_START:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_START** = ``250``
Mensaje MIDI enviado para iniciar la secuencia o canción actual desde el principio.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_CONTINUE:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_CONTINUE** = ``251``
Mensaje MIDI enviado para reanudar la secuencia o canción actual desde el punto en que se pausó.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_STOP:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_STOP** = ``252``
Mensaje MIDI enviado para pausar la secuencia o canción actual.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_ACTIVE_SENSING:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_ACTIVE_SENSING** = ``254``
Mensaje MIDI enviado repetidamente mientras el dispositivo MIDI está inactivo, para indicar al receptor que la conexión sigue activa. La mayoría de los dispositivos MIDI no envían este mensaje.
.. _class_@GlobalScope_constant_MIDI_MESSAGE_SYSTEM_RESET:
.. rst-class:: classref-enumeration-constant
:ref:`MIDIMessage<enum_@GlobalScope_MIDIMessage>` **MIDI_MESSAGE_SYSTEM_RESET** = ``255``
Mensaje MIDI enviado para restablecer un dispositivo MIDI a su estado predeterminado, como si recién se hubiera encendido. No debe enviarse al encender el dispositivo MIDI.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Error:
.. rst-class:: classref-enumeration
enum **Error**: :ref:`🔗<enum_@GlobalScope_Error>`
.. _class_@GlobalScope_constant_OK:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **OK** = ``0``
Los métodos que devuelven :ref:`Error<enum_@GlobalScope_Error>` devuelven :ref:`OK<class_@GlobalScope_constant_OK>` cuando no se ha producido ningún error.
Dado que :ref:`OK<class_@GlobalScope_constant_OK>` tiene el valor ``0``, y todas las demás constantes de error son enteros positivos, también se puede utilizar en comprobaciones booleanas.
::
var error = method_that_returns_error()
if error != OK:
printerr("¡Fallo!")
# O, alternativamente:
if error:
printerr("¡Sigue fallando!")
\ **Nota:** Muchas funciones no devuelven un código de error, sino que imprimen mensajes de error en la salida estándar.
.. _class_@GlobalScope_constant_FAILED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **FAILED** = ``1``
Error genérico.
.. _class_@GlobalScope_constant_ERR_UNAVAILABLE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNAVAILABLE** = ``2``
Error no disponible.
.. _class_@GlobalScope_constant_ERR_UNCONFIGURED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNCONFIGURED** = ``3``
Error sin configurar.
.. _class_@GlobalScope_constant_ERR_UNAUTHORIZED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_UNAUTHORIZED** = ``4``
Error no autorizado.
.. _class_@GlobalScope_constant_ERR_PARAMETER_RANGE_ERROR:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_PARAMETER_RANGE_ERROR** = ``5``
Error de rango de parámetros.
.. _class_@GlobalScope_constant_ERR_OUT_OF_MEMORY:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_OUT_OF_MEMORY** = ``6``
Error de falta de memoria (OOM).
.. _class_@GlobalScope_constant_ERR_FILE_NOT_FOUND:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_NOT_FOUND** = ``7``
Archivo: Error archivo no encontrado.
.. _class_@GlobalScope_constant_ERR_FILE_BAD_DRIVE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_BAD_DRIVE** = ``8``
Archivo: Error de unidad defectuosa.
.. _class_@GlobalScope_constant_ERR_FILE_BAD_PATH:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_BAD_PATH** = ``9``
Archivo: Error ruta incorrecta.
.. _class_@GlobalScope_constant_ERR_FILE_NO_PERMISSION:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_NO_PERMISSION** = ``10``
Archivo: Error sin permiso.
.. _class_@GlobalScope_constant_ERR_FILE_ALREADY_IN_USE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_ALREADY_IN_USE** = ``11``
Archivo: Error archivo ya esta siendo usado.
.. _class_@GlobalScope_constant_ERR_FILE_CANT_OPEN:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_OPEN** = ``12``
Archivo: Error no se puede abrir.
.. _class_@GlobalScope_constant_ERR_FILE_CANT_WRITE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_WRITE** = ``13``
Archivo: Error no se puede escribir.
.. _class_@GlobalScope_constant_ERR_FILE_CANT_READ:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CANT_READ** = ``14``
Archivo: Error no se puede leer.
.. _class_@GlobalScope_constant_ERR_FILE_UNRECOGNIZED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_UNRECOGNIZED** = ``15``
Archivo: Error no reconocido.
.. _class_@GlobalScope_constant_ERR_FILE_CORRUPT:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_CORRUPT** = ``16``
Archivo: Error de corrupción.
.. _class_@GlobalScope_constant_ERR_FILE_MISSING_DEPENDENCIES:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_MISSING_DEPENDENCIES** = ``17``
Archivo: Error no se encuentran las dependencias.
.. _class_@GlobalScope_constant_ERR_FILE_EOF:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_FILE_EOF** = ``18``
Archivo: Error Fin de fichero (EOF).
.. _class_@GlobalScope_constant_ERR_CANT_OPEN:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_OPEN** = ``19``
Error: No se puede abrir.
.. _class_@GlobalScope_constant_ERR_CANT_CREATE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_CREATE** = ``20``
Error: No se puede crear.
.. _class_@GlobalScope_constant_ERR_QUERY_FAILED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_QUERY_FAILED** = ``21``
Error: Fallo en la consulta.
.. _class_@GlobalScope_constant_ERR_ALREADY_IN_USE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_ALREADY_IN_USE** = ``22``
Error: Ya está en uso.
.. _class_@GlobalScope_constant_ERR_LOCKED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_LOCKED** = ``23``
Error Bloqueado (Locked error).
.. _class_@GlobalScope_constant_ERR_TIMEOUT:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_TIMEOUT** = ``24``
Error: Tiempo de espera excedido.
.. _class_@GlobalScope_constant_ERR_CANT_CONNECT:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_CONNECT** = ``25``
Error: No se puede conectar.
.. _class_@GlobalScope_constant_ERR_CANT_RESOLVE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_RESOLVE** = ``26``
Error: No se puede resolver.
.. _class_@GlobalScope_constant_ERR_CONNECTION_ERROR:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CONNECTION_ERROR** = ``27``
Error de conexión.
.. _class_@GlobalScope_constant_ERR_CANT_ACQUIRE_RESOURCE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_ACQUIRE_RESOURCE** = ``28``
Error: No se pudo adquirir el recurso.
.. _class_@GlobalScope_constant_ERR_CANT_FORK:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CANT_FORK** = ``29``
Error: No se pudo bifurcar el proceso.
.. _class_@GlobalScope_constant_ERR_INVALID_DATA:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_DATA** = ``30``
Error de datos inválidos.
.. _class_@GlobalScope_constant_ERR_INVALID_PARAMETER:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_PARAMETER** = ``31``
Error de parámetro inválido.
.. _class_@GlobalScope_constant_ERR_ALREADY_EXISTS:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_ALREADY_EXISTS** = ``32``
Error: Ya existe.
.. _class_@GlobalScope_constant_ERR_DOES_NOT_EXIST:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_DOES_NOT_EXIST** = ``33``
Error: No existe.
.. _class_@GlobalScope_constant_ERR_DATABASE_CANT_READ:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_DATABASE_CANT_READ** = ``34``
Base de datos: Error de lectura.
.. _class_@GlobalScope_constant_ERR_DATABASE_CANT_WRITE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_DATABASE_CANT_WRITE** = ``35``
Base de datos: Error de escritura.
.. _class_@GlobalScope_constant_ERR_COMPILATION_FAILED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_COMPILATION_FAILED** = ``36``
Error de compilación fallida.
.. _class_@GlobalScope_constant_ERR_METHOD_NOT_FOUND:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_METHOD_NOT_FOUND** = ``37``
Error: Método no encontrado.
.. _class_@GlobalScope_constant_ERR_LINK_FAILED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_LINK_FAILED** = ``38``
Error de enlace fallido.
.. _class_@GlobalScope_constant_ERR_SCRIPT_FAILED:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_SCRIPT_FAILED** = ``39``
Error de script fallido.
.. _class_@GlobalScope_constant_ERR_CYCLIC_LINK:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_CYCLIC_LINK** = ``40``
Error de enlazado cíclico (import cycle).
.. _class_@GlobalScope_constant_ERR_INVALID_DECLARATION:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_INVALID_DECLARATION** = ``41``
Error de declaración inválida.
.. _class_@GlobalScope_constant_ERR_DUPLICATE_SYMBOL:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_DUPLICATE_SYMBOL** = ``42``
Error de símbolo duplicado.
.. _class_@GlobalScope_constant_ERR_PARSE_ERROR:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_PARSE_ERROR** = ``43``
Error de análisis.
.. _class_@GlobalScope_constant_ERR_BUSY:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_BUSY** = ``44``
Error recurso ocupado.
.. _class_@GlobalScope_constant_ERR_SKIP:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_SKIP** = ``45``
Error de omisión.
.. _class_@GlobalScope_constant_ERR_HELP:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_HELP** = ``46``
Error de ayuda. Se usa internamente al pasar ``--version`` o ``--help`` como opciones ejecutables.
.. _class_@GlobalScope_constant_ERR_BUG:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_BUG** = ``47``
Error causado por un problema de implementación en el método.
\ **Nota:** Si un método integrado devuelve este código, por favor abre una incidencia en el `Rastreador de incidencias de GitHub <https://github.com/godotengine/godot/issues>`__.
.. _class_@GlobalScope_constant_ERR_PRINTER_ON_FIRE:
.. rst-class:: classref-enumeration-constant
:ref:`Error<enum_@GlobalScope_Error>` **ERR_PRINTER_ON_FIRE** = ``48``
Error de impresora en llamas. (Este es un huevo de pascua, ningún método del motor devuelve este código de error).
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_PropertyHint:
.. rst-class:: classref-enumeration
enum **PropertyHint**: :ref:`🔗<enum_@GlobalScope_PropertyHint>`
.. _class_@GlobalScope_constant_PROPERTY_HINT_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NONE** = ``0``
La propiedad no tiene ninguna sugerencia para el editor.
.. _class_@GlobalScope_constant_PROPERTY_HINT_RANGE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_RANGE** = ``1``
Hints that an :ref:`int<class_int>` or :ref:`float<class_float>` property should be within a range specified via the hint string ``"min,max"`` or ``"min,max,step"``. The hint string can optionally include ``"or_greater"`` and/or ``"or_less"`` to allow manual input going respectively above the max or below the min values.
\ **Example:** ``"-360,360,1,or_greater,or_less"``.
Additionally, other keywords can be included: ``"exp"`` for exponential range editing, ``"radians_as_degrees"`` for editing radian angles in degrees (the range values are also in degrees), ``"degrees"`` to hint at an angle, ``"prefer_slider"`` to show the slider for integers, ``"hide_control"`` to hide the slider or up-down arrows, and ``"suffix:px/s"`` to display a suffix indicating the value's unit (e.g. ``px/s`` for pixels per second).
.. _class_@GlobalScope_constant_PROPERTY_HINT_ENUM:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ENUM** = ``2``
Hints that an :ref:`int<class_int>`, :ref:`String<class_String>`, or :ref:`StringName<class_StringName>` property is an enumerated value to pick in a list specified via a hint string.
The hint string is a comma separated list of names such as ``"Hello,Something,Else"``. Whitespace is **not** removed from either end of a name. For integer properties, the first name in the list has value 0, the next 1, and so on. Explicit values can also be specified by appending ``:integer`` to the name, e.g. ``"Zero,One,Three:3,Four,Six:6"``.
.. _class_@GlobalScope_constant_PROPERTY_HINT_ENUM_SUGGESTION:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ENUM_SUGGESTION** = ``3``
Hints that a :ref:`String<class_String>` or :ref:`StringName<class_StringName>` property can be an enumerated value to pick in a list specified via a hint string such as ``"Hello,Something,Else"``. See :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>` for details.
Unlike :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>`, a property with this hint still accepts arbitrary values and can be empty. The list of values serves to suggest possible values.
.. _class_@GlobalScope_constant_PROPERTY_HINT_EXP_EASING:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_EXP_EASING** = ``4``
Sugiere que una propiedad :ref:`float<class_float>` debe ser editada mediante una función de atenuación exponencial. La string de pista puede incluir ``"attenuation"`` para voltear la curva horizontalmente y/o ``"positive_only"`` para excluir la atenuación de entrada/salida y limitar los valores para que sean mayores o iguales a cero.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LINK:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LINK** = ``5``
Sugiere que una propiedad vectorial debe permitir que sus componentes se enlacen. Por ejemplo, esto permite que :ref:`Vector2.x<class_Vector2_property_x>` y :ref:`Vector2.y<class_Vector2_property_y>` se editen juntos.
.. _class_@GlobalScope_constant_PROPERTY_HINT_FLAGS:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FLAGS** = ``6``
Hints that an :ref:`int<class_int>` property is a bitmask with named bit flags.
The hint string is a comma separated list of names such as ``"Bit0,Bit1,Bit2,Bit3"``. Whitespace is **not** removed from either end of a name. The first name in the list has value 1, the next 2, then 4, 8, 16 and so on. Explicit values can also be specified by appending ``:integer`` to the name, e.g. ``"A:4,B:8,C:16"``. You can also combine several flags (``"A:4,B:8,AB:12,C:16"``).
\ **Note:** A flag value must be at least ``1`` and at most ``2 ** 32 - 1``.
\ **Note:** Unlike :ref:`PROPERTY_HINT_ENUM<class_@GlobalScope_constant_PROPERTY_HINT_ENUM>`, the previous explicit value is not taken into account. For the hint ``"A:16,B,C"``, A is 16, B is 2, C is 4.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_RENDER:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_RENDER** = ``7``
Indica que una propiedad :ref:`int<class_int>` es una máscara de bits usando las, opcionalmente nombradas, capas de renderizado 2D.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_PHYSICS:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_PHYSICS** = ``8``
Indica que una propiedad :ref:`int<class_int>` es una máscara de bits usando las, opcionalmente nombradas, capas de física 2D.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_2D_NAVIGATION:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_2D_NAVIGATION** = ``9``
Sugiere que una propiedad :ref:`int<class_int>` es una máscara de bits que utiliza las capas de navegación 2D, opcionalmente nombradas.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_RENDER:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_RENDER** = ``10``
Sugiere que una propiedad :ref:`int<class_int>` es una máscara de bits que utiliza las capas de renderizado 3D, opcionalmente nombradas.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_PHYSICS:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_PHYSICS** = ``11``
Sugiere que una propiedad :ref:`int<class_int>` es una máscara de bits que utiliza las capas físicas 3D, opcionalmente nombradas.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_3D_NAVIGATION:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_3D_NAVIGATION** = ``12``
Sugiere que una propiedad :ref:`int<class_int>` es una máscara de bits utilizando las capas de navegación 3D con nombres opcionales.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LAYERS_AVOIDANCE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LAYERS_AVOIDANCE** = ``37``
Sugiere que una propiedad entera es una máscara de bits utilizando las capas de evitación con nombres opcionales.
.. _class_@GlobalScope_constant_PROPERTY_HINT_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FILE** = ``13``
Sugiere que una propiedad :ref:`String<class_String>` es una ruta a un archivo. Editarla mostrará un diálogo de archivo para seleccionar la ruta. La string de sugerencia puede ser un conjunto de filtros con comodines como ``"*.png,*.jpg"``. Por defecto, el archivo se guardará como UID siempre que esté disponible. Puedes usar los métodos :ref:`ResourceUID<class_ResourceUID>` para convertirlo de nuevo a la ruta. Para guardar una ruta raw, usa :ref:`PROPERTY_HINT_FILE_PATH<class_@GlobalScope_constant_PROPERTY_HINT_FILE_PATH>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_DIR:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_DIR** = ``14``
Sugiere que una propiedad :ref:`String<class_String>` es una ruta a un directorio. Editarla mostrará un diálogo de archivo para seleccionar la ruta.
.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_FILE** = ``15``
Sugiere que una propiedad :ref:`String<class_String>` es una ruta absoluta a un archivo fuera de la carpeta del proyecto. Editarla mostrará un diálogo de archivo para seleccionar la ruta. La string de sugerencia puede ser un conjunto de filtros con comodines como ``"*.png,*.jpg"``.
.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_DIR:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_DIR** = ``16``
Sugiere que una propiedad de tipo :ref:`String<class_String>` es una ruta absoluta a un directorio fuera de la carpeta del proyecto. Al editarla, se mostrará un diálogo de archivo para seleccionar la ruta.
.. _class_@GlobalScope_constant_PROPERTY_HINT_RESOURCE_TYPE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_RESOURCE_TYPE** = ``17``
Sugiere que una propiedad es una instancia de un tipo derivado de :ref:`Resource<class_Resource>`, opcionalmente especificado a través de la string de sugerencia (p. ej., ``"Texture2D"``). Al editarla, se mostrará un menú emergente de tipos de recursos válidos para instanciar.
.. _class_@GlobalScope_constant_PROPERTY_HINT_MULTILINE_TEXT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_MULTILINE_TEXT** = ``18``
Hints that a :ref:`String<class_String>` property is text with line breaks. Editing it will show a text input field where line breaks can be typed.
The hint string can be set to ``"monospace"`` to force the input field to use a monospaced font.
If the hint string ``"no_wrap"`` is set, the input field will not wrap lines at boundaries, instead resorting to making the area scrollable.
.. _class_@GlobalScope_constant_PROPERTY_HINT_EXPRESSION:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_EXPRESSION** = ``19``
Indica que una propiedad :ref:`String<class_String>` es una :ref:`Expression<class_Expression>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_PLACEHOLDER_TEXT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_PLACEHOLDER_TEXT** = ``20``
Sugiere que una propiedad de tipo :ref:`String<class_String>` debe mostrar un texto de marcador de posición en su campo de entrada si está vacío. La string de sugerencia es el texto de marcador de posición que se usará.
.. _class_@GlobalScope_constant_PROPERTY_HINT_COLOR_NO_ALPHA:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_COLOR_NO_ALPHA** = ``21``
Sugiere que una propiedad de tipo :ref:`Color<class_Color>` debe editarse sin afectar su transparencia (:ref:`Color.a<class_Color_property_a>` no es editable).
.. _class_@GlobalScope_constant_PROPERTY_HINT_OBJECT_ID:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_OBJECT_ID** = ``22``
Indica que el valor de la propiedad es un objeto codificado como ID de objeto, con su tipo especificado en la string de indicación. Usado por el depurador.
.. _class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_TYPE_STRING** = ``23``
Si una propiedad es :ref:`String<class_String>`, indica que la propiedad representa un tipo particular (clase). Esto permite seleccionar un tipo desde el diálogo de creación. La propiedad almacenará el tipo seleccionado como una string.
Si una propiedad es :ref:`Array<class_Array>`, indica al editor cómo mostrar los elementos. ``hint_string`` debe codificar tipos anidados usando ``":"`` y ``"/"``.
Si una propiedad es :ref:`Dictionary<class_Dictionary>`, indica al editor cómo mostrar los elementos. ``hint_string`` es lo mismo que :ref:`Array<class_Array>`, con un ``";"`` separando la clave y el valor.
.. tabs::
.. code-tab:: gdscript
# Array de elem_type.
hint_string = "%d:" % [elem_type]
hint_string = "%d/%d:%s" % [elem_type, elem_hint, elem_hint_string]
# Array bidimensional de elem_type (array de arrays de elem_type).
hint_string = "%d:%d:" % [TYPE_ARRAY, elem_type]
hint_string = "%d:%d/%d:%s" % [TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]
# Array tridimensional de elem_type (array de arrays de arrays de elem_type).
hint_string = "%d:%d:%d:" % [TYPE_ARRAY, TYPE_ARRAY, elem_type]
hint_string = "%d:%d:%d/%d:%s" % [TYPE_ARRAY, TYPE_ARRAY, elem_type, elem_hint, elem_hint_string]
.. code-tab:: csharp
// Array de elemType.
hintString = $"{elemType:D}:";
hintString = $"{elemType:}/{elemHint:D}:{elemHintString}";
// Array bidimensional de elemType (array de arrays de elemType).
hintString = $"{Variant.Type.Array:D}:{elemType:D}:";
hintString = $"{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";
// Array tridimensional de elemType (array de arrays de arrays de elemType).
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}:";
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Array:D}:{elemType:D}/{elemHint:D}:{elemHintString}";
\ **Ejemplos:**\
.. tabs::
.. code-tab:: gdscript
hint_string = "%d:" % [TYPE_INT] # Array de enteros.
hint_string = "%d/%d:1,10,1" % [TYPE_INT, PROPERTY_HINT_RANGE] # Array de enteros (en el rango de 1 a 10).
hint_string = "%d/%d:Zero,One,Two" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array de enteros (un enum).
hint_string = "%d/%d:Zero,One,Three:3,Six:6" % [TYPE_INT, PROPERTY_HINT_ENUM] # Array de enteros (un enum).
hint_string = "%d/%d:*.png" % [TYPE_STRING, PROPERTY_HINT_FILE] # Array de strings (rutas de archivos).
hint_string = "%d/%d:Texture2D" % [TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Array de texturas.
hint_string = "%d:%d:" % [TYPE_ARRAY, TYPE_FLOAT] # Array bidimensional de floats.
hint_string = "%d:%d/%d:" % [TYPE_ARRAY, TYPE_STRING, PROPERTY_HINT_MULTILINE_TEXT] # Array bidimensional de strings multilínea.
hint_string = "%d:%d/%d:-1,1,0.1" % [TYPE_ARRAY, TYPE_FLOAT, PROPERTY_HINT_RANGE] # Array bidimensional de floats (en rango de -1 a 1).
hint_string = "%d:%d/%d:Texture2D" % [TYPE_ARRAY, TYPE_OBJECT, PROPERTY_HINT_RESOURCE_TYPE] # Array bidimensional de texturas.
.. code-tab:: csharp
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Range:D}:1,10,1"; // Array de enteros (en rango de 1 a 10).
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Two"; // Array de enteros (un enum).
hintString = $"{Variant.Type.Int:D}/{PropertyHint.Enum:D}:Zero,One,Three:3,Six:6"; // Array de enteros (un enum).
hintString = $"{Variant.Type.String:D}/{PropertyHint.File:D}:*.png"; // Array de strings (rutas de archivos).
hintString = $"{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Array de texturas.
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}:"; // Array bidimensional de floats.
hintString = $"{Variant.Type.Array:D}:{Variant.Type.String:D}/{PropertyHint.MultilineText:D}:"; // Array bidimensional de strings multilínea.
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Float:D}/{PropertyHint.Range:D}:-1,1,0.1"; // Array bidimensional de floats (en rango de -1 a 1).
hintString = $"{Variant.Type.Array:D}:{Variant.Type.Object:D}/{PropertyHint.ResourceType:D}:Texture2D"; // Array bidimensional de texturas.
\ **Nota:** Los dos puntos finales son necesarios para detectar correctamente los tipos integrados.
.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE** = ``24``
**Obsoleto:** This hint is not used by the engine.
.. _class_@GlobalScope_constant_PROPERTY_HINT_OBJECT_TOO_BIG:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_OBJECT_TOO_BIG** = ``25``
Indica que un objeto es demasiado grande para ser enviado a través del depurador.
.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_PATH_VALID_TYPES:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_PATH_VALID_TYPES** = ``26``
Indica que la string de indicación especifica tipos de nodos válidos para una propiedad de tipo :ref:`NodePath<class_NodePath>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_SAVE_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_SAVE_FILE** = ``27``
Sugiere que una propiedad de tipo :ref:`String<class_String>` es una ruta a un archivo. Al editarla, se mostrará un diálogo de archivo para seleccionar la ruta del archivo que se guardará. El diálogo tiene acceso al directorio del proyecto. La string de sugerencia puede ser un conjunto de filtros con comodines como ``"*.png,*.jpg"``. Véase también :ref:`FileDialog.filters<class_FileDialog_property_filters>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_GLOBAL_SAVE_FILE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GLOBAL_SAVE_FILE** = ``28``
Sugiere que una propiedad de tipo :ref:`String<class_String>` es una ruta a un archivo. Al editarla, se mostrará un diálogo de archivo para seleccionar la ruta del archivo que se guardará. El diálogo tiene acceso a todo el sistema de archivos. La string de sugerencia puede ser un conjunto de filtros con comodines como ``"*.png,*.jpg"``. Véase también :ref:`FileDialog.filters<class_FileDialog_property_filters>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_INT_IS_OBJECTID:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INT_IS_OBJECTID** = ``29``
**Obsoleto:** This hint is not used by the engine.
.. _class_@GlobalScope_constant_PROPERTY_HINT_INT_IS_POINTER:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INT_IS_POINTER** = ``30``
Sugiere que una propiedad :ref:`int<class_int>` es un puntero. Usado por GDExtension.
.. _class_@GlobalScope_constant_PROPERTY_HINT_ARRAY_TYPE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ARRAY_TYPE** = ``31``
Sugiere que una propiedad es un :ref:`Array<class_Array>` con el tipo almacenado especificado en la string de sugerencia. La string de sugerencia contiene el tipo del array (ej. ``"String"``).
Utiliza el formato de string de sugerencia de :ref:`PROPERTY_HINT_TYPE_STRING<class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING>` para tener más control sobre el tipo almacenado.
.. _class_@GlobalScope_constant_PROPERTY_HINT_DICTIONARY_TYPE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_DICTIONARY_TYPE** = ``38``
Indica que una propiedad es un :ref:`Dictionary<class_Dictionary>` que contiene tipos específicos usando una string. La string contiene una clave y valor separados por punto y coma (p. ej. ``"int;String"``).
Usa el formato de string de pista de :ref:`PROPERTY_HINT_TYPE_STRING<class_@GlobalScope_constant_PROPERTY_HINT_TYPE_STRING>` para un mayor control sobre los tipos almacenados.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LOCALE_ID:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LOCALE_ID** = ``32``
Sugiere que una propiedad de tipo string es un código de configuración regional. Al editarla, se mostrará un diálogo de configuración regional para seleccionar el idioma y el país.
.. _class_@GlobalScope_constant_PROPERTY_HINT_LOCALIZABLE_STRING:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_LOCALIZABLE_STRING** = ``33``
Indica que una propiedad tipo diccionario es un mapa de traducción de strings. Las claves del diccionario son códigos de idioma y los valores son las strings traducidas.
.. _class_@GlobalScope_constant_PROPERTY_HINT_NODE_TYPE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_NODE_TYPE** = ``34``
Sugiere que una propiedad es una instancia de un tipo derivado de :ref:`Node<class_Node>`, especificado opcionalmente a través de la string de sugerencias (p. ej., ``"Node2D"``). Al editarla, se mostrará un diálogo para seleccionar un nodo de la escena.
.. _class_@GlobalScope_constant_PROPERTY_HINT_HIDE_QUATERNION_EDIT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_HIDE_QUATERNION_EDIT** = ``35``
Indica que una propiedad de tipo cuaternión debe desactivar el editor temporal de ángulos de Euler.
.. _class_@GlobalScope_constant_PROPERTY_HINT_PASSWORD:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_PASSWORD** = ``36``
Indica que una propiedad de tipo string es una contraseña, y cada carácter se reemplaza con un carácter secreto.
.. _class_@GlobalScope_constant_PROPERTY_HINT_TOOL_BUTTON:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_TOOL_BUTTON** = ``39``
Sugiere que una propiedad :ref:`Callable<class_Callable>` debe mostrarse como un botón presionable. Cuando se presiona el botón, se llama al invocable. La string de sugerencia especifica el texto del botón y, opcionalmente, un icono del tipo de tema ``"EditorIcons"``.
.. code:: text
"¡Haz clic aquí!" - Un botón con el texto "¡Haz clic aquí!" y el icono "Callable" predeterminado.
"¡Haz clic aquí!,ColorRect" - Un botón con el texto "¡Haz clic aquí!" y el icono "ColorRect".
\ **Nota:** Un :ref:`Callable<class_Callable>` no puede ser serializado y almacenado correctamente en un archivo, por lo que se recomienda utilizar :ref:`PROPERTY_USAGE_EDITOR<class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR>` en lugar de :ref:`PROPERTY_USAGE_DEFAULT<class_@GlobalScope_constant_PROPERTY_USAGE_DEFAULT>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_ONESHOT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_ONESHOT** = ``40``
Sugiere que una propiedad cambiará por sí sola después de la configuración, como :ref:`AudioStreamPlayer.playing<class_AudioStreamPlayer_property_playing>` o :ref:`GPUParticles3D.emitting<class_GPUParticles3D_property_emitting>`.
.. _class_@GlobalScope_constant_PROPERTY_HINT_GROUP_ENABLE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_GROUP_ENABLE** = ``42``
Sugiere que una propiedad booleana habilitará la función asociada con el grupo en el que aparece. La propiedad se mostrará como una casilla de verificación en el encabezado del grupo. Solo funciona dentro de un grupo o subgrupo.
Por defecto, la desactivación de la propiedad oculta todas las propiedades del grupo. Utiliza la string de sugerencia opcional ``"checkbox_only"`` para desactivar este comportamiento.
.. _class_@GlobalScope_constant_PROPERTY_HINT_INPUT_NAME:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_INPUT_NAME** = ``43``
Sugiere que una propiedad :ref:`String<class_String>` o :ref:`StringName<class_StringName>` es el nombre de una acción de entrada. Esto permite la selección de cualquier nombre de acción del Mapa de entrada en la Configuración del Proyecto. La string de sugerencia puede contener dos opciones separadas por comas:
- Si contiene ``"show_builtin"``, las acciones de entrada incorporadas se incluyen en la selección.
- Si contiene ``"loose_mode"``, el modo loose está habilitado. Esto permite insertar cualquier nombre de acción, incluso si no está presente en el mapa de entrada.
.. _class_@GlobalScope_constant_PROPERTY_HINT_FILE_PATH:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_FILE_PATH** = ``44``
Similar a :ref:`PROPERTY_HINT_FILE<class_@GlobalScope_constant_PROPERTY_HINT_FILE>`, pero la propiedad se almacena como una ruta raw, no como UID. Eso significa que la referencia se romperá si mueves el archivo. Considera usar :ref:`PROPERTY_HINT_FILE<class_@GlobalScope_constant_PROPERTY_HINT_FILE>` cuando sea posible.
.. _class_@GlobalScope_constant_PROPERTY_HINT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyHint<enum_@GlobalScope_PropertyHint>` **PROPERTY_HINT_MAX** = ``45``
Representa el tamaño del enum :ref:`PropertyHint<enum_@GlobalScope_PropertyHint>`.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_PropertyUsageFlags:
.. rst-class:: classref-enumeration
flags **PropertyUsageFlags**: :ref:`🔗<enum_@GlobalScope_PropertyUsageFlags>`
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NONE** = ``0``
La propiedad no se almacena ni se muestra en el editor. Este es el comportamiento predeterminado para propiedades no exportadas.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_STORAGE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_STORAGE** = ``2``
La propiedad se serializa y se guarda en el archivo de la escena (por defecto para propiedades exportadas).
.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR** = ``4``
La propiedad se muestra en el :ref:`EditorInspector<class_EditorInspector>` (por defecto para propiedades exportadas).
.. _class_@GlobalScope_constant_PROPERTY_USAGE_INTERNAL:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_INTERNAL** = ``8``
La propiedad se excluye de la referencia de la clase.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_CHECKABLE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CHECKABLE** = ``16``
La propiedad se puede comprobar en el :ref:`EditorInspector<class_EditorInspector>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_CHECKED:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CHECKED** = ``32``
La propiedad se comprueba en el :ref:`EditorInspector<class_EditorInspector>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_GROUP:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_GROUP** = ``64``
Se utiliza para agrupar propiedades en el editor. Véase :ref:`EditorInspector<class_EditorInspector>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_CATEGORY:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CATEGORY** = ``128``
Se usa para categorizar las propiedades juntas en el editor.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_SUBGROUP:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SUBGROUP** = ``256``
Se utiliza para agrupar propiedades en el editor en un subgrupo (bajo un grupo). Véase :ref:`EditorInspector<class_EditorInspector>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_CLASS_IS_BITFIELD:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CLASS_IS_BITFIELD** = ``512``
La propiedad es un campo de bits, es decir, contiene múltiples banderas representadas como bits.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NO_INSTANCE_STATE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NO_INSTANCE_STATE** = ``1024``
La propiedad no guarda su estado en :ref:`PackedScene<class_PackedScene>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_RESTART_IF_CHANGED:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_RESTART_IF_CHANGED** = ``2048``
Al editar la propiedad, el usuario debe reiniciar el editor para que el cambio tenga efecto.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SCRIPT_VARIABLE** = ``4096``
La propiedad es una variable de script. :ref:`PROPERTY_USAGE_SCRIPT_VARIABLE<class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE>` se puede utilizar para distinguir entre las variables de script exportadas y las variables incorporadas (que no tienen este flag de uso). Por defecto, :ref:`PROPERTY_USAGE_SCRIPT_VARIABLE<class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_VARIABLE>` **no** se aplica a las variables que se crean al sobrescribir :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>` en un script.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_STORE_IF_NULL:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_STORE_IF_NULL** = ``8192``
El valor de la propiedad de tipo :ref:`Object<class_Object>` se almacenará incluso si su valor es ``null``.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED** = ``16384``
Si esta propiedad se modifica, todos los campos del inspector se actualizarán.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SCRIPT_DEFAULT_VALUE** = ``32768``
**Obsoleto:** This flag is not used by the engine.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_CLASS_IS_ENUM:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_CLASS_IS_ENUM** = ``65536``
La propiedad es una variable de tipo enum, solo acepta constantes enteras nombradas de su enumeración asociada.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NIL_IS_VARIANT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NIL_IS_VARIANT** = ``131072``
Si la propiedad tiene ``nil`` como valor predeterminado, su tipo será :ref:`Variant<class_Variant>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_ARRAY** = ``262144``
The property is the element count of a property array, i.e. a list of groups of related properties. Properties defined with this usage also need a specific ``class_name`` field in the form of ``label,prefix``. The field may also include additional comma-separated options:
- ``page_size=N``: Overrides :ref:`EditorSettings.interface/inspector/max_array_dictionary_items_per_page<class_EditorSettings_property_interface/inspector/max_array_dictionary_items_per_page>` for this array.
- ``add_button_text=text``: The text displayed by the "Add Element" button.
- ``static``: The elements can't be re-arranged.
- ``const``: New elements can't be added.
- ``numbered``: An index will appear next to each element.
- ``unfoldable``: The array can't be folded.
- ``swap_method=method_name``: The method that will be called when two elements switch places. The method should take 2 :ref:`int<class_int>` parameters, which will be indices of the elements being swapped.
Note that making a full-fledged property array requires boilerplate code involving :ref:`Object._get_property_list()<class_Object_private_method__get_property_list>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_ALWAYS_DUPLICATE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_ALWAYS_DUPLICATE** = ``524288``
Al duplicar un recurso con :ref:`Resource.duplicate()<class_Resource_method_duplicate>`, y este flag está establecido en una propiedad de ese recurso, la propiedad siempre debe ser duplicada, independientemente del parámetro bool ``subresources``.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NEVER_DUPLICATE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NEVER_DUPLICATE** = ``1048576``
Al duplicar un recurso con :ref:`Resource.duplicate()<class_Resource_method_duplicate>`, y este flag está establecido en una propiedad de ese recurso, la propiedad nunca debe ser duplicada, independientemente del parámetro bool ``subresources``.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_HIGH_END_GFX:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_HIGH_END_GFX** = ``2097152``
La propiedad solo se muestra en el editor si se admiten renderizadores modernos (se excluye el método de renderizado de compatibilidad).
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NODE_PATH_FROM_SCENE_ROOT** = ``4194304``
La propiedad :ref:`NodePath<class_NodePath>` siempre será relativa a la raíz de la escena. Principalmente útil para recursos locales.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_RESOURCE_NOT_PERSISTENT** = ``8388608``
Se usa cuando un recurso se crea dinámicamente, es decir, el getter siempre devuelve una instancia diferente. :ref:`ResourceSaver<class_ResourceSaver>` necesita esta información para guardar correctamente dichos recursos.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_KEYING_INCREMENTS:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_KEYING_INCREMENTS** = ``16777216``
Insertar un fotograma clave de animación de esta propiedad incrementará automáticamente el valor, permitiendo animar fácilmente múltiples valores consecutivos.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_DEFERRED_SET_RESOURCE:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_DEFERRED_SET_RESOURCE** = ``33554432``
**Obsoleto:** This flag is not used by the engine.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR_INSTANTIATE_OBJECT** = ``67108864``
Cuando esta propiedad es un :ref:`Resource<class_Resource>` y el objeto base es un :ref:`Node<class_Node>`, se creará automáticamente una instancia del recurso cada vez que el nodo se cree en el editor.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_EDITOR_BASIC_SETTING:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_EDITOR_BASIC_SETTING** = ``134217728``
La propiedad se considera una configuración básica y aparecerá incluso cuando el modo avanzado esté desactivado. Se usa para configuraciones del proyecto.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_READ_ONLY:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_READ_ONLY** = ``268435456``
La propiedad es de solo lectura en el :ref:`EditorInspector<class_EditorInspector>`.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_SECRET:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_SECRET** = ``536870912``
Una propiedad de preset de exportación con esta bandera contiene información confidencial y se almacena por separado del resto de la configuración del preset de exportación.
.. _class_@GlobalScope_constant_PROPERTY_USAGE_DEFAULT:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_DEFAULT** = ``6``
Uso por defecto (almacenamiento y editor).
.. _class_@GlobalScope_constant_PROPERTY_USAGE_NO_EDITOR:
.. rst-class:: classref-enumeration-constant
:ref:`PropertyUsageFlags<enum_@GlobalScope_PropertyUsageFlags>` **PROPERTY_USAGE_NO_EDITOR** = ``2``
Uso por defecto, pero sin mostrar la propiedad en el editor (almacenamiento).
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_MethodFlags:
.. rst-class:: classref-enumeration
flags **MethodFlags**: :ref:`🔗<enum_@GlobalScope_MethodFlags>`
.. _class_@GlobalScope_constant_METHOD_FLAG_NORMAL:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_NORMAL** = ``1``
Bandera para un método normal.
.. _class_@GlobalScope_constant_METHOD_FLAG_EDITOR:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_EDITOR** = ``2``
Bandera para un método editor.
.. _class_@GlobalScope_constant_METHOD_FLAG_CONST:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_CONST** = ``4``
Bandera para un método constante.
.. _class_@GlobalScope_constant_METHOD_FLAG_VIRTUAL:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VIRTUAL** = ``8``
Bandera para un método virtual.
.. _class_@GlobalScope_constant_METHOD_FLAG_VARARG:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VARARG** = ``16``
Indicador para un método con un número variable de argumentos.
.. _class_@GlobalScope_constant_METHOD_FLAG_STATIC:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_STATIC** = ``32``
Bandera para un método estático.
.. _class_@GlobalScope_constant_METHOD_FLAG_OBJECT_CORE:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_OBJECT_CORE** = ``64``
Uso interno. Permite no volcar métodos virtuales centrales (como :ref:`Object._notification()<class_Object_private_method__notification>`) en la API JSON.
.. _class_@GlobalScope_constant_METHOD_FLAG_VIRTUAL_REQUIRED:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAG_VIRTUAL_REQUIRED** = ``128``
Bandera para un método virtual que es requerido. En GDScript, este flag se establece para funciones abstractas.
.. _class_@GlobalScope_constant_METHOD_FLAGS_DEFAULT:
.. rst-class:: classref-enumeration-constant
:ref:`MethodFlags<enum_@GlobalScope_MethodFlags>` **METHOD_FLAGS_DEFAULT** = ``1``
Banderas de método por defecto (normal).
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Variant.Type:
.. rst-class:: classref-enumeration
enum **Variant.Type**: :ref:`🔗<enum_@GlobalScope_Variant.Type>`
.. _class_@GlobalScope_constant_TYPE_NIL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_NIL** = ``0``
La variable es ``null``.
.. _class_@GlobalScope_constant_TYPE_BOOL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_BOOL** = ``1``
La variable es de tipo :ref:`bool<class_bool>`.
.. _class_@GlobalScope_constant_TYPE_INT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_INT** = ``2``
La variable es de tipo :ref:`int<class_int>`.
.. _class_@GlobalScope_constant_TYPE_FLOAT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_FLOAT** = ``3``
La variable es de tipo :ref:`float<class_float>`.
.. _class_@GlobalScope_constant_TYPE_STRING:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_STRING** = ``4``
La variable es de tipo :ref:`String<class_String>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR2:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR2** = ``5``
La variable es de tipo :ref:`Vector2<class_Vector2>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR2I:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR2I** = ``6``
La variable es de tipo :ref:`Vector2i<class_Vector2i>`.
.. _class_@GlobalScope_constant_TYPE_RECT2:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RECT2** = ``7``
La variable es de tipo :ref:`Rect2<class_Rect2>`.
.. _class_@GlobalScope_constant_TYPE_RECT2I:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RECT2I** = ``8``
La variable es de tipo :ref:`Rect2i<class_Rect2i>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR3:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR3** = ``9``
La variable es de tipo :ref:`Vector3<class_Vector3>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR3I:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR3I** = ``10``
La variable es de tipo :ref:`Vector3i<class_Vector3i>`.
.. _class_@GlobalScope_constant_TYPE_TRANSFORM2D:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_TRANSFORM2D** = ``11``
La variable es de tipo :ref:`Transform2D<class_Transform2D>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR4:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR4** = ``12``
La variable es de tipo :ref:`Vector4<class_Vector4>`.
.. _class_@GlobalScope_constant_TYPE_VECTOR4I:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_VECTOR4I** = ``13``
La variable es de tipo :ref:`Vector4i<class_Vector4i>`.
.. _class_@GlobalScope_constant_TYPE_PLANE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PLANE** = ``14``
La variable es de tipo :ref:`Plane<class_Plane>`.
.. _class_@GlobalScope_constant_TYPE_QUATERNION:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_QUATERNION** = ``15``
La variable es de tipo :ref:`Quaternion<class_Quaternion>`.
.. _class_@GlobalScope_constant_TYPE_AABB:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_AABB** = ``16``
La variable es de tipo :ref:`AABB<class_AABB>`.
.. _class_@GlobalScope_constant_TYPE_BASIS:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_BASIS** = ``17``
La variable es de tipo :ref:`Basis<class_Basis>`.
.. _class_@GlobalScope_constant_TYPE_TRANSFORM3D:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_TRANSFORM3D** = ``18``
La variable es de tipo :ref:`Transform3D<class_Transform3D>`.
.. _class_@GlobalScope_constant_TYPE_PROJECTION:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PROJECTION** = ``19``
La variable es de tipo :ref:`Projection<class_Projection>`.
.. _class_@GlobalScope_constant_TYPE_COLOR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_COLOR** = ``20``
La variable es de tipo :ref:`Color<class_Color>`.
.. _class_@GlobalScope_constant_TYPE_STRING_NAME:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_STRING_NAME** = ``21``
La variable es de tipo :ref:`StringName<class_StringName>`.
.. _class_@GlobalScope_constant_TYPE_NODE_PATH:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_NODE_PATH** = ``22``
La variable es de tipo :ref:`NodePath<class_NodePath>`.
.. _class_@GlobalScope_constant_TYPE_RID:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_RID** = ``23``
La variable es de tipo :ref:`RID<class_RID>`.
.. _class_@GlobalScope_constant_TYPE_OBJECT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_OBJECT** = ``24``
La variable es de tipo :ref:`Object<class_Object>`.
.. _class_@GlobalScope_constant_TYPE_CALLABLE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_CALLABLE** = ``25``
La variable es de tipo :ref:`Callable<class_Callable>`.
.. _class_@GlobalScope_constant_TYPE_SIGNAL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_SIGNAL** = ``26``
La variable es de tipo :ref:`Signal<class_Signal>`.
.. _class_@GlobalScope_constant_TYPE_DICTIONARY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_DICTIONARY** = ``27``
La variable es de tipo :ref:`Dictionary<class_Dictionary>`.
.. _class_@GlobalScope_constant_TYPE_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_ARRAY** = ``28``
La variable es de tipo :ref:`Array<class_Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_BYTE_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_BYTE_ARRAY** = ``29``
La variable es de tipo :ref:`PackedByteArray<class_PackedByteArray>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_INT32_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_INT32_ARRAY** = ``30``
La variable es de tipo :ref:`PackedInt32Array<class_PackedInt32Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_INT64_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_INT64_ARRAY** = ``31``
La variable es de tipo :ref:`PackedInt64Array<class_PackedInt64Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_FLOAT32_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_FLOAT32_ARRAY** = ``32``
La variable es de tipo :ref:`PackedFloat32Array<class_PackedFloat32Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_FLOAT64_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_FLOAT64_ARRAY** = ``33``
La variable es de tipo :ref:`PackedFloat64Array<class_PackedFloat64Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_STRING_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_STRING_ARRAY** = ``34``
La variable es de tipo :ref:`PackedStringArray<class_PackedStringArray>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR2_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR2_ARRAY** = ``35``
La variable es de tipo :ref:`PackedVector2Array<class_PackedVector2Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR3_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR3_ARRAY** = ``36``
La variable es de tipo :ref:`PackedVector3Array<class_PackedVector3Array>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_COLOR_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_COLOR_ARRAY** = ``37``
La variable es de tipo :ref:`PackedColorArray<class_PackedColorArray>`.
.. _class_@GlobalScope_constant_TYPE_PACKED_VECTOR4_ARRAY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_PACKED_VECTOR4_ARRAY** = ``38``
La variable es de tipo :ref:`PackedVector2Array<class_PackedVector2Array>`.
.. _class_@GlobalScope_constant_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` **TYPE_MAX** = ``39``
Representa el tamaño del enum :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.
.. rst-class:: classref-item-separator
----
.. _enum_@GlobalScope_Variant.Operator:
.. rst-class:: classref-enumeration
enum **Variant.Operator**: :ref:`🔗<enum_@GlobalScope_Variant.Operator>`
.. _class_@GlobalScope_constant_OP_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_EQUAL** = ``0``
Operador de igualdad (``==``).
.. _class_@GlobalScope_constant_OP_NOT_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NOT_EQUAL** = ``1``
Operador desigualdad (``!=``).
.. _class_@GlobalScope_constant_OP_LESS:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_LESS** = ``2``
Operador menor que (``<``).
.. _class_@GlobalScope_constant_OP_LESS_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_LESS_EQUAL** = ``3``
Operador menor o igual que (``<=``).
.. _class_@GlobalScope_constant_OP_GREATER:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_GREATER** = ``4``
Operador mayor que (``>``).
.. _class_@GlobalScope_constant_OP_GREATER_EQUAL:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_GREATER_EQUAL** = ``5``
Operador igual o mayor que (``>=``).
.. _class_@GlobalScope_constant_OP_ADD:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_ADD** = ``6``
Operador suma (``+``).
.. _class_@GlobalScope_constant_OP_SUBTRACT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SUBTRACT** = ``7``
Operador resta (``-``).
.. _class_@GlobalScope_constant_OP_MULTIPLY:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MULTIPLY** = ``8``
Operador multiplicación (``*``).
.. _class_@GlobalScope_constant_OP_DIVIDE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_DIVIDE** = ``9``
Operador división (``/``).
.. _class_@GlobalScope_constant_OP_NEGATE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NEGATE** = ``10``
Operador unario de negación (``-``.
.. _class_@GlobalScope_constant_OP_POSITIVE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_POSITIVE** = ``11``
Operador unario de suma (``+``).
.. _class_@GlobalScope_constant_OP_MODULE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MODULE** = ``12``
Operador modulo/resto (``%``).
.. _class_@GlobalScope_constant_OP_POWER:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_POWER** = ``13``
Operador de exponenciación (``**``).
.. _class_@GlobalScope_constant_OP_SHIFT_LEFT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SHIFT_LEFT** = ``14``
Operador de desplazamiento binario izquierdo (``<<``).
.. _class_@GlobalScope_constant_OP_SHIFT_RIGHT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_SHIFT_RIGHT** = ``15``
Operador de desplazamiento binario derecho (``>>``).
.. _class_@GlobalScope_constant_OP_BIT_AND:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_AND** = ``16``
Operador binario AND (``&``).
.. _class_@GlobalScope_constant_OP_BIT_OR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_OR** = ``17``
Operador binario OR (``|``).
.. _class_@GlobalScope_constant_OP_BIT_XOR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_XOR** = ``18``
Operador binario XOR (``^``).
.. _class_@GlobalScope_constant_OP_BIT_NEGATE:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_BIT_NEGATE** = ``19``
Operador binario NOT (``~``).
.. _class_@GlobalScope_constant_OP_AND:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_AND** = ``20``
Operador AND lógico (``and`` o ``&&``).
.. _class_@GlobalScope_constant_OP_OR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_OR** = ``21``
Operador OR lógico (``or`` o ``||``).
.. _class_@GlobalScope_constant_OP_XOR:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_XOR** = ``22``
Operador XOR lógico ( no implementado en GDScript).
.. _class_@GlobalScope_constant_OP_NOT:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_NOT** = ``23``
Operador NOT lógico (``NOT`` o ``!``).
.. _class_@GlobalScope_constant_OP_IN:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_IN** = ``24``
Operador lógico In (``in``).
.. _class_@GlobalScope_constant_OP_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>` **OP_MAX** = ``25``
Representa el tamaño del enum :ref:`Variant.Operator<enum_@GlobalScope_Variant.Operator>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_@GlobalScope_property_AudioServer:
.. rst-class:: classref-property
:ref:`AudioServer<class_AudioServer>` **AudioServer** :ref:`🔗<class_@GlobalScope_property_AudioServer>`
El singleton :ref:`AudioServer<class_AudioServer>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_CameraServer:
.. rst-class:: classref-property
:ref:`CameraServer<class_CameraServer>` **CameraServer** :ref:`🔗<class_@GlobalScope_property_CameraServer>`
El singleton :ref:`CameraServer<class_CameraServer>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ClassDB:
.. rst-class:: classref-property
:ref:`ClassDB<class_ClassDB>` **ClassDB** :ref:`🔗<class_@GlobalScope_property_ClassDB>`
El singleton :ref:`ClassDB<class_ClassDB>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_DisplayServer:
.. rst-class:: classref-property
:ref:`DisplayServer<class_DisplayServer>` **DisplayServer** :ref:`🔗<class_@GlobalScope_property_DisplayServer>`
El singleton :ref:`DisplayServer<class_DisplayServer>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_EditorInterface:
.. rst-class:: classref-property
:ref:`EditorInterface<class_EditorInterface>` **EditorInterface** :ref:`🔗<class_@GlobalScope_property_EditorInterface>`
El singleton :ref:`EditorInterface<class_EditorInterface>`.
\ **Nota:** Solo disponible en compilaciones del editor.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Engine:
.. rst-class:: classref-property
:ref:`Engine<class_Engine>` **Engine** :ref:`🔗<class_@GlobalScope_property_Engine>`
El singleton :ref:`Engine<class_Engine>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_EngineDebugger:
.. rst-class:: classref-property
:ref:`EngineDebugger<class_EngineDebugger>` **EngineDebugger** :ref:`🔗<class_@GlobalScope_property_EngineDebugger>`
El singleton :ref:`EngineDebugger<class_EngineDebugger>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_GDExtensionManager:
.. rst-class:: classref-property
:ref:`GDExtensionManager<class_GDExtensionManager>` **GDExtensionManager** :ref:`🔗<class_@GlobalScope_property_GDExtensionManager>`
El singleton :ref:`GDExtensionManager<class_GDExtensionManager>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Geometry2D:
.. rst-class:: classref-property
:ref:`Geometry2D<class_Geometry2D>` **Geometry2D** :ref:`🔗<class_@GlobalScope_property_Geometry2D>`
El singleton :ref:`Geometry2D<class_Geometry2D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Geometry3D:
.. rst-class:: classref-property
:ref:`Geometry3D<class_Geometry3D>` **Geometry3D** :ref:`🔗<class_@GlobalScope_property_Geometry3D>`
El singleton :ref:`Geometry3D<class_Geometry3D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_IP:
.. rst-class:: classref-property
:ref:`IP<class_IP>` **IP** :ref:`🔗<class_@GlobalScope_property_IP>`
El singleton :ref:`IP<class_IP>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Input:
.. rst-class:: classref-property
:ref:`Input<class_Input>` **Input** :ref:`🔗<class_@GlobalScope_property_Input>`
El singleton :ref:`Input<class_Input>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_InputMap:
.. rst-class:: classref-property
:ref:`InputMap<class_InputMap>` **InputMap** :ref:`🔗<class_@GlobalScope_property_InputMap>`
El singleton :ref:`InputMap<class_InputMap>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_JavaClassWrapper:
.. rst-class:: classref-property
:ref:`JavaClassWrapper<class_JavaClassWrapper>` **JavaClassWrapper** :ref:`🔗<class_@GlobalScope_property_JavaClassWrapper>`
El singleton :ref:`JavaClassWrapper<class_JavaClassWrapper>` .
\ **Nota:** Sólo implementado en Android.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_JavaScriptBridge:
.. rst-class:: classref-property
:ref:`JavaScriptBridge<class_JavaScriptBridge>` **JavaScriptBridge** :ref:`🔗<class_@GlobalScope_property_JavaScriptBridge>`
El singleton :ref:`JavaScriptBridge<class_JavaScriptBridge>`.
\ **Nota:** Solo se implementa en la plataforma web.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Marshalls:
.. rst-class:: classref-property
:ref:`Marshalls<class_Marshalls>` **Marshalls** :ref:`🔗<class_@GlobalScope_property_Marshalls>`
El singleton :ref:`Marshalls<class_Marshalls>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NativeMenu:
.. rst-class:: classref-property
:ref:`NativeMenu<class_NativeMenu>` **NativeMenu** :ref:`🔗<class_@GlobalScope_property_NativeMenu>`
El singleton :ref:`NativeMenu<class_NativeMenu>`.
\ **Nota:** Solo implementado en macOS.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NavigationMeshGenerator:
.. rst-class:: classref-property
:ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>` **NavigationMeshGenerator** :ref:`🔗<class_@GlobalScope_property_NavigationMeshGenerator>`
El singleton :ref:`NavigationMeshGenerator<class_NavigationMeshGenerator>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NavigationServer2D:
.. rst-class:: classref-property
:ref:`NavigationServer2D<class_NavigationServer2D>` **NavigationServer2D** :ref:`🔗<class_@GlobalScope_property_NavigationServer2D>`
El singleton :ref:`NavigationServer2D<class_NavigationServer2D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NavigationServer2DManager:
.. rst-class:: classref-property
:ref:`NavigationServer2DManager<class_NavigationServer2DManager>` **NavigationServer2DManager** :ref:`🔗<class_@GlobalScope_property_NavigationServer2DManager>`
The :ref:`NavigationServer2DManager<class_NavigationServer2DManager>` singleton.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NavigationServer3D:
.. rst-class:: classref-property
:ref:`NavigationServer3D<class_NavigationServer3D>` **NavigationServer3D** :ref:`🔗<class_@GlobalScope_property_NavigationServer3D>`
El singleton :ref:`NavigationServer3D<class_NavigationServer3D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_NavigationServer3DManager:
.. rst-class:: classref-property
:ref:`NavigationServer3DManager<class_NavigationServer3DManager>` **NavigationServer3DManager** :ref:`🔗<class_@GlobalScope_property_NavigationServer3DManager>`
The :ref:`NavigationServer3DManager<class_NavigationServer3DManager>` singleton.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_OS:
.. rst-class:: classref-property
:ref:`OS<class_OS>` **OS** :ref:`🔗<class_@GlobalScope_property_OS>`
El singleton :ref:`OS<class_OS>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Performance:
.. rst-class:: classref-property
:ref:`Performance<class_Performance>` **Performance** :ref:`🔗<class_@GlobalScope_property_Performance>`
El singleton :ref:`Performance<class_Performance>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_PhysicsServer2D:
.. rst-class:: classref-property
:ref:`PhysicsServer2D<class_PhysicsServer2D>` **PhysicsServer2D** :ref:`🔗<class_@GlobalScope_property_PhysicsServer2D>`
El singleton :ref:`PhysicsServer2D<class_PhysicsServer2D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_PhysicsServer2DManager:
.. rst-class:: classref-property
:ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>` **PhysicsServer2DManager** :ref:`🔗<class_@GlobalScope_property_PhysicsServer2DManager>`
El singleton :ref:`PhysicsServer2DManager<class_PhysicsServer2DManager>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_PhysicsServer3D:
.. rst-class:: classref-property
:ref:`PhysicsServer3D<class_PhysicsServer3D>` **PhysicsServer3D** :ref:`🔗<class_@GlobalScope_property_PhysicsServer3D>`
El singleton :ref:`PhysicsServer3D<class_PhysicsServer3D>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_PhysicsServer3DManager:
.. rst-class:: classref-property
:ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>` **PhysicsServer3DManager** :ref:`🔗<class_@GlobalScope_property_PhysicsServer3DManager>`
El singleton :ref:`PhysicsServer3DManager<class_PhysicsServer3DManager>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ProjectSettings:
.. rst-class:: classref-property
:ref:`ProjectSettings<class_ProjectSettings>` **ProjectSettings** :ref:`🔗<class_@GlobalScope_property_ProjectSettings>`
El singleton :ref:`ProjectSettings<class_ProjectSettings>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_RenderingServer:
.. rst-class:: classref-property
:ref:`RenderingServer<class_RenderingServer>` **RenderingServer** :ref:`🔗<class_@GlobalScope_property_RenderingServer>`
El singleton :ref:`RenderingServer<class_RenderingServer>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ResourceLoader:
.. rst-class:: classref-property
:ref:`ResourceLoader<class_ResourceLoader>` **ResourceLoader** :ref:`🔗<class_@GlobalScope_property_ResourceLoader>`
El singleton :ref:`ResourceLoader<class_ResourceLoader>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ResourceSaver:
.. rst-class:: classref-property
:ref:`ResourceSaver<class_ResourceSaver>` **ResourceSaver** :ref:`🔗<class_@GlobalScope_property_ResourceSaver>`
El singleton :ref:`ResourceSaver<class_ResourceSaver>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ResourceUID:
.. rst-class:: classref-property
:ref:`ResourceUID<class_ResourceUID>` **ResourceUID** :ref:`🔗<class_@GlobalScope_property_ResourceUID>`
El singleton :ref:`ResourceUID<class_ResourceUID>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_TextServerManager:
.. rst-class:: classref-property
:ref:`TextServerManager<class_TextServerManager>` **TextServerManager** :ref:`🔗<class_@GlobalScope_property_TextServerManager>`
El singleton :ref:`TextServerManager<class_TextServerManager>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_ThemeDB:
.. rst-class:: classref-property
:ref:`ThemeDB<class_ThemeDB>` **ThemeDB** :ref:`🔗<class_@GlobalScope_property_ThemeDB>`
El singleton :ref:`ThemeDB<class_ThemeDB>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_Time:
.. rst-class:: classref-property
:ref:`Time<class_Time>` **Time** :ref:`🔗<class_@GlobalScope_property_Time>`
El singleton :ref:`Time<class_Time>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_TranslationServer:
.. rst-class:: classref-property
:ref:`TranslationServer<class_TranslationServer>` **TranslationServer** :ref:`🔗<class_@GlobalScope_property_TranslationServer>`
El singleton :ref:`TranslationServer<class_TranslationServer>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_WorkerThreadPool:
.. rst-class:: classref-property
:ref:`WorkerThreadPool<class_WorkerThreadPool>` **WorkerThreadPool** :ref:`🔗<class_@GlobalScope_property_WorkerThreadPool>`
El singleton :ref:`WorkerThreadPool<class_WorkerThreadPool>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_property_XRServer:
.. rst-class:: classref-property
:ref:`XRServer<class_XRServer>` **XRServer** :ref:`🔗<class_@GlobalScope_property_XRServer>`
El singleton :ref:`XRServer<class_XRServer>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_@GlobalScope_method_abs:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **abs**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_abs>`
Devuelve el valor absoluto de un parámetro :ref:`Variant<class_Variant>` ``x`` (es decir, un valor no negativo). Tipos admitidos: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
var a = abs(-1)
# a es 1
var b = abs(-1.2)
# b es 1.2
var c = abs(Vector2(-3.5, -4))
# c es (3.5, 4)
var d = abs(Vector2i(-5, -6))
# d es (5, 6)
var e = abs(Vector3(-7, 8.5, -3.8))
# e es (7, 8.5, 3.8)
var f = abs(Vector3i(-7, -8, -9))
# f es (7, 8, 9)
\ **Nota:** Para mayor seguridad de tipos, utiliza :ref:`absf()<class_@GlobalScope_method_absf>`, :ref:`absi()<class_@GlobalScope_method_absi>`, :ref:`Vector2.abs()<class_Vector2_method_abs>`, :ref:`Vector2i.abs()<class_Vector2i_method_abs>`, :ref:`Vector3.abs()<class_Vector3_method_abs>`, :ref:`Vector3i.abs()<class_Vector3i_method_abs>`, :ref:`Vector4.abs()<class_Vector4_method_abs>` o :ref:`Vector4i.abs()<class_Vector4i_method_abs>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_absf:
.. rst-class:: classref-method
:ref:`float<class_float>` **absf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_absf>`
Devuelve el valor absoluto del parámetro float ``x`` (es decir, un valor positivo).
::
# a vale 1.2
var a = absf(-1.2)
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_absi:
.. rst-class:: classref-method
:ref:`int<class_int>` **absi**\ (\ x\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_absi>`
Devuelve el valor absoluto del parámetro int ``x`` (es decir, un valor positivo).
::
# a vale 1
var a = absi(-1)
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_acos:
.. rst-class:: classref-method
:ref:`float<class_float>` **acos**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_acos>`
Devuelve el arco coseno de ``x`` en radianes. Se usa para obtener el ángulo del coseno de ``x``. ``x`` debe estar entre ``-1.0`` y ``1.0`` (inclusivo); en otro caso, :ref:`acos()<class_@GlobalScope_method_acos>` devolverá :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
::
# c es 0.523599 o 30 grados si se convierte con rad2deg(s)
c = acos(0.866025)
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_acosh:
.. rst-class:: classref-method
:ref:`float<class_float>` **acosh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_acosh>`
Devuelve el arco coseno hiperbólico (también llamado inverso) de ``x``, devolviendo un valor en radianes. Se usa para obtener el ángulo a partir del coseno de un ángulo en el espacio hiperbólico si ``x`` es mayor o igual a 1. Para valores de ``x`` menores que 1, devolverá 0 para evitar que :ref:`acosh()<class_@GlobalScope_method_acosh>` devuelva :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
::
var a = acosh(2) # Devuelve 1.31695789692482
cosh(a) # Devuelve 2
var b = acosh(-1) # Devuelve 0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_angle_difference:
.. rst-class:: classref-method
:ref:`float<class_float>` **angle_difference**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_angle_difference>`
Devuelve la diferencia entre dos ángulos (en radianes), en el rango ``[-PI, +PI]``. Cuando ``from`` y ``to`` son opuestos, devuelve ``-PI`` si ``from`` es menor que ``to``, o ``PI`` en caso contrario.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_asin:
.. rst-class:: classref-method
:ref:`float<class_float>` **asin**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_asin>`
Devuelve el arcoseno de ``x`` en radianes. Úsalo para obtener el ángulo del seno de ``x``. ``x`` será ajustado entre ``-1.0`` y ``1.0`` (inclusivo), con el fin de prevenir que :ref:`asin()<class_@GlobalScope_method_asin>` devuelva :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
::
# s es 0.523599 o 30 grados si se convierte con rad_to_deg(s)
var s = asin(0.5)
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_asinh:
.. rst-class:: classref-method
:ref:`float<class_float>` **asinh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_asinh>`
Devuelve el arco hiperbólico (también llamado seno inverso) de ``x``, devolviendo un valor en radianes. Úsalo para obtener el ángulo a partir del seno de un ángulo en el espacio hiperbólico.
::
var a = asinh(0.9) # Devuelve 0.8088669356527824
sinh(a) # Devuelve 0.9
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_atan:
.. rst-class:: classref-method
:ref:`float<class_float>` **atan**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atan>`
Devuelve el arco tangente de ``x`` en radianes. Úsalo para obtener el ángulo a partir de la tangente de un ángulo en trigonometría.
El método no puede saber en qué cuadrante se encuentra el ángulo. Véase :ref:`atan2()<class_@GlobalScope_method_atan2>` si tienes tanto ``y`` como ``x``\
::
var a = atan(0.5) # a is 0.463648
Si ``x`` está entre lo valores ``-PI / 2`` y ``PI / 2`` (inclusivo), ``atan(tan(x))`` es igual a ``x``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_atan2:
.. rst-class:: classref-method
:ref:`float<class_float>` **atan2**\ (\ y\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atan2>`
Devuelve la arcotangente de ``y/x`` en radianes. Úsalo para obtener el ángulo de la tangente ``y/x``. Para obtener el valor, el método tiene en cuenta el signo de ambos argumentos para determinar el cuadrante.
Nota importante: La coordenada Y es la primera, por convención.
::
a = atan2(0, -1) # a es 3.141593
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_atanh:
.. rst-class:: classref-method
:ref:`float<class_float>` **atanh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_atanh>`
Devuelve la tangente del arco hiperbólico (también llamado inverso) de ``x``, devolviendo un valor en radianes. Úsalo para obtener el ángulo desde la tangente en un ángulo en espacio hiperbólico si ``x`` está entre -1 y 1 (no inclusivo).
En matemáticas, la inversa de la tangente hiperbólica es solo definida por -1 < ``x`` <1 en el conjunto real, por lo que valores iguales o menores a -1 para ``x`` develven :ref:`@GDScript.INF<class_@GDScript_constant_INF>` negativos y valores iguales o mayores a 1 devuelven :ref:`@GDScript.INF<class_@GDScript_constant_INF>` positivo para prevenir que :ref:`atanh()<class_@GlobalScope_method_atanh>` devuelva :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`.
::
var a = atanh(0.9) # Devuelve 1.47221948958322
tanh(a) # Devuelve 0.9
var b = atanh(-2) # Devuelve -inf
tanh(b) # Devuelve -1
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_bezier_derivative:
.. rst-class:: classref-method
:ref:`float<class_float>` **bezier_derivative**\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_bezier_derivative>`
Devuelve el derivado que se le dio a ``t`` en un unidimensional `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ definida dados los puntos ``control_1``, ``control_2``, y ``end``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_bezier_interpolate:
.. rst-class:: classref-method
:ref:`float<class_float>` **bezier_interpolate**\ (\ start\: :ref:`float<class_float>`, control_1\: :ref:`float<class_float>`, control_2\: :ref:`float<class_float>`, end\: :ref:`float<class_float>`, t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_bezier_interpolate>`
Devuelve el punto en el ``t`` dado en una `curva de Bézier <https://en.wikipedia.org/wiki/B%C3%A9zier_curve>`__ unidimensional definida por los puntos ``control_1``, ``control_2`` y ``end`` dados.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_bytes_to_var:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **bytes_to_var**\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_@GlobalScope_method_bytes_to_var>`
Decodifica un array de bytes devolviendo el valor :ref:`Variant<class_Variant>`,sin decodificar objetos.
\ **Nota:** Si necesitas deserialización de objetos, Véase :ref:`bytes_to_var_with_objects()<class_@GlobalScope_method_bytes_to_var_with_objects>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_bytes_to_var_with_objects:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **bytes_to_var_with_objects**\ (\ bytes\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_@GlobalScope_method_bytes_to_var_with_objects>`
Decodifica un array de bytes a un valor :ref:`Variant<class_Variant>`. Se permite la decodificación de objetos.
\ **Advertencia:** El objeto deserializado puede contener código que se ejecuta. No utilices esta opción si el objeto serializado proviene de fuentes no confiables para evitar posibles amenazas de seguridad (ejecución remota de código).
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_ceil:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **ceil**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_ceil>`
Redondea ``x`` hacia arriba (hacia infinito positivo), devolviendo el valor entero más pequeño que no es menor que ``x``. Tipos soportados: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
var i = ceil(1.45) # i es 2.0
i = ceil(1.001) # i es 2.0
Véase también :ref:`floor()<class_@GlobalScope_method_floor>`, :ref:`round()<class_@GlobalScope_method_round>`, y :ref:`snapped()<class_@GlobalScope_method_snapped>`.
\ **Nota:** Para una mejor seguridad de tipos, usa :ref:`ceilf()<class_@GlobalScope_method_ceilf>`, :ref:`ceili()<class_@GlobalScope_method_ceili>`, :ref:`Vector2.ceil()<class_Vector2_method_ceil>`, :ref:`Vector3.ceil()<class_Vector3_method_ceil>` o :ref:`Vector4.ceil()<class_Vector4_method_ceil>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_ceilf:
.. rst-class:: classref-method
:ref:`float<class_float>` **ceilf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ceilf>`
Redondea ``x`` hacia arriba (hacia el infinito positivo) y devuelve el número entero más pequeño que no sea menor que ``x``.
Una versión de :ref:`ceil()<class_@GlobalScope_method_ceil>` con seguridad de tipos, que devuelve un :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_ceili:
.. rst-class:: classref-method
:ref:`int<class_int>` **ceili**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ceili>`
Redondea ``x`` hacia arriba (hacia el infinito positivo) y devuelve el número entero más pequeño que no sea menor que ``x``.
Una versión de tipo seguro de :ref:`ceil()<class_@GlobalScope_method_ceil>`, que devuelve un :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_clamp:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **clamp**\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_clamp>`
Restringe el ``value``, devolviendo una :ref:`Variant<class_Variant>` no menor que ``min`` y no mayor que ``max``. Cualquier valor que pueda ser comparado con los operadores "menor que" y "mayor que" funcionará.
::
var a = clamp(-10, -1, 5)
# a is -1
var b = clamp(8.1, 0.9, 5.5)
# b is 5.5
\ **Nota:** Para mejor seguridad de tipo, utiliza :ref:`clampf()<class_@GlobalScope_method_clampf>`, :ref:`clampi()<class_@GlobalScope_method_clampi>`, :ref:`Vector2.clamp()<class_Vector2_method_clamp>`, :ref:`Vector3.clamp()<class_Vector3_method_clamp>`, :ref:`Vector3i.clamp()<class_Vector3i_method_clamp>`, :ref:`Vector4.clamp()<class_Vector4_method_clamp>`, :ref:`Vector4i.clamp()<class_Vector4i_method_clamp>`, o :ref:`Color.clamp()<class_Color_method_clamp>` (Actualmente no compatible con este método).
\ **Nota:** Cuando utilices esto en vectores *no* realizará restricción de componentes, y elegirá ``min`` si ``value < min`` or ``max`` si ``value > max``. Para realizar restrición de componentes utiliza los metodos listados arriba.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_clampf:
.. rst-class:: classref-method
:ref:`float<class_float>` **clampf**\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_clampf>`
Fija el ``value``, devolviendo un :ref:`float<class_float>` no menor que ``min`` y no mayor que ``max``.
::
var speed = 42.1
var a = clampf(speed, 1.0, 20.5) # a es 20.5
speed = -10.0
var b = clampf(speed, -1.0, 1.0) # b es -1.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_clampi:
.. rst-class:: classref-method
:ref:`int<class_int>` **clampi**\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_clampi>`
Acota el ``value`` y devuelve un :ref:`int<class_int>` no menor que ``min`` ni mayor que ``max``.
::
var speed = 42
var a = clampi(speed, 1, 20) # a es 20
speed = -10
var b = clampi(speed, -1, 1) # b es -1
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cos:
.. rst-class:: classref-method
:ref:`float<class_float>` **cos**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cos>`
Devuelve el coseno del ángulo ``angle_rad`` en radianes.
::
cos(PI * 2) # Devuelve 1.0
cos(PI) # Devuelve -1.0
cos(grados_a_rad(90)) # Devuelve 0.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cosh:
.. rst-class:: classref-method
:ref:`float<class_float>` **cosh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cosh>`
Devuelve el coseno hiperbólico de ``x`` en radianes.
::
print(cosh(1)) # Imprime 1.543081
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cubic_interpolate:
.. rst-class:: classref-method
:ref:`float<class_float>` **cubic_interpolate**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate>`
Realiza una interpolación cúbica entre dos valores en base al factor definido en ``weight`` con los valores de ``pre`` y ``post``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cubic_interpolate_angle:
.. rst-class:: classref-method
:ref:`float<class_float>` **cubic_interpolate_angle**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_angle>`
Realiza una interpolación cúbica entre dos valores de rotación con la ruta más corta por el factor definido en ``weight`` con los valores de ``pre`` y ``post``. Véase también :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cubic_interpolate_angle_in_time:
.. rst-class:: classref-method
:ref:`float<class_float>` **cubic_interpolate_angle_in_time**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_angle_in_time>`
Realiza una interpolación cúbica entre dos valores rotacionales por el camino más corto definido por el factor definido en los valores ``weight`` con ``pre`` y ``post``. Véase también :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`.
Puede realizar una interpolación mas suave usando valores del tiempo en comparación con :ref:`cubic_interpolate()<class_@GlobalScope_method_cubic_interpolate>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_cubic_interpolate_in_time:
.. rst-class:: classref-method
:ref:`float<class_float>` **cubic_interpolate_in_time**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, pre\: :ref:`float<class_float>`, post\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`, to_t\: :ref:`float<class_float>`, pre_t\: :ref:`float<class_float>`, post_t\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_cubic_interpolate_in_time>`
Realiza una interpolación cúbica entre dos valores según el factor definido en ``weight`` con los valores de ``pre`` y ``post``.
Puede realizar una interpolación más suave que :ref:`cubic_interpolate()<class_@GlobalScope_method_cubic_interpolate>` por valores de tiempo.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_db_to_linear:
.. rst-class:: classref-method
:ref:`float<class_float>` **db_to_linear**\ (\ db\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_db_to_linear>`
Convierte de decibelios a energía lineal (audio).
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_deg_to_rad:
.. rst-class:: classref-method
:ref:`float<class_float>` **deg_to_rad**\ (\ deg\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_deg_to_rad>`
Convierte un ángulo expresado en grados a radianes.
::
var r = deg_to_rad(180) # r is 3.141593
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_ease:
.. rst-class:: classref-method
:ref:`float<class_float>` **ease**\ (\ x\: :ref:`float<class_float>`, curve\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_ease>`
Devuelve un valor "atenuado" de ``x`` basado en una función de atenuación definida con ``curve``. Esta función de atenuación se basa en un exponente. ``curve`` puede ser cualquier número de punto flotante, con valores específicos que conducen a los siguientes comportamientos:
.. code:: text
- Menor que -1.0 (exclusivo): Atenuación de entrada y salida
- -1.0: Lineal
- Entre -1.0 y 0.0 (exclusivo): Atenuación de salida y entrada
- 0.0: Constante
- Entre 0.0 y 1.0 (exclusivo): Atenuación de salida
- 1.0: Lineal
- Mayor que 1.0 (exclusivo): Atenuación de entrada
\ `Hoja de referencia de valores de curva ease() <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/ease_cheatsheet.png>`__\
Véase también :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`. Si necesitas realizar transiciones más avanzadas, utiliza :ref:`Tween.interpolate_value()<class_Tween_method_interpolate_value>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_error_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **error_string**\ (\ error\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_error_string>`
Devuelve un nombre entendible para los humanos para el siguiente código :ref:`Error<enum_@GlobalScope_Error>`.
::
print(OK) # Imprime 0
print(error_string(OK)) # Imprime "OK"
print(error_string(ERR_BUSY)) # Imprime "Busy"
print(error_string(ERR_OUT_OF_MEMORY)) # Imprime "Out of memory"
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_exp:
.. rst-class:: classref-method
:ref:`float<class_float>` **exp**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_exp>`
La función exponencial natural. Eleva la constante matemática *e* a la potencia de ``x`` y la devuelve.
\ *e* tiene un valor aproximado de 2,71828, y puede obtenerse con ``exp(1)``.
Para potencias con otras bases, utiliza el método :ref:`pow()<class_@GlobalScope_method_pow>`.
::
var a = exp(2) # Aproximadamente 7.39
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_floor:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **floor**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_floor>`
Redondea ``x`` por debajo (hacia el infinito negativo), devolviendo el número entero más grande que no es mayor que ``x``. Tipos soportados: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
var a = floor(2.99) # a es 2.0
a = floor(-2.99) # a es -3.0
Véase también: :ref:`ceil()<class_@GlobalScope_method_ceil>`, :ref:`round()<class_@GlobalScope_method_round>`, :ref:`snapped()<class_@GlobalScope_method_snapped>`.
\ **Nota:** Para una mayor seguridad con tipos, utiliza :ref:`floorf()<class_@GlobalScope_method_floorf>`, :ref:`floori()<class_@GlobalScope_method_floori>`, :ref:`Vector2.floor()<class_Vector2_method_floor>`, :ref:`Vector3.floor()<class_Vector3_method_floor>`, o :ref:`Vector4.floor()<class_Vector4_method_floor>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_floorf:
.. rst-class:: classref-method
:ref:`float<class_float>` **floorf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_floorf>`
Redondea a ``x`` hacia abajo (hacia el negativo infinito), devolviendo el numero entero de mayor tamaño que no sea superior a ``x``.
Una version con tipado seguro de :ref:`floor()<class_@GlobalScope_method_floor>`, que devuelve un :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_floori:
.. rst-class:: classref-method
:ref:`int<class_int>` **floori**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_floori>`
Redondea a ``x`` hacia abajo (hacia el negativo infinito), devolviendo el numero entero de mayor tamaño que no sea superior a ``x``.
Una version con tipado seguro de :ref:`floor()<class_@GlobalScope_method_floor>`, que devuelve un :ref:`int<class_int>`.
\ **Nota:** Esta función *no* es la misma que ``int(x)``, la cual redondea hacia 0.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_fmod:
.. rst-class:: classref-method
:ref:`float<class_float>` **fmod**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_fmod>`
Devuelve el residuo punto flotante de ``x`` dividido por ``y``, manteniendo el signo de ``x``.
::
var residuo = fmod(7, 5.5) # residuo es 1.5
Para la operación de residuo de números de tipo integer, utiliza el operador ``%``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_fposmod:
.. rst-class:: classref-method
:ref:`float<class_float>` **fposmod**\ (\ x\: :ref:`float<class_float>`, y\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_fposmod>`
Devuelve el módulo de punto flotante de ``x`` dividido por ``y``, que envuelve por igual en positivo y en negativo.
::
print(" (x) (fmod(x, 1.5)) (fposmod(x, 1.5))")
for i in 7:
var x = 0.5 * i - 1.5
print("%4.1f %4.1f %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)])
Imprime:
.. code:: text
(x) (fmod(x, 1.5)) (fposmod(x, 1.5))
-1.5 -0.0 0.0
-1.0 -1.0 0.5
-0.5 -0.5 1.0
0.0 0.0 0.0
0.5 0.5 0.5
1.0 1.0 1.0
1.5 0.0 0.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_hash>`
Devuelve el hash de tipo integer de la variable ``variable`` pasada.
.. tabs::
.. code-tab:: gdscript
print(hash("a")) # Imprime 177670
.. code-tab:: csharp
GD.Print(GD.Hash("a")); // Imprime 177670
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_instance_from_id:
.. rst-class:: classref-method
:ref:`Object<class_Object>` **instance_from_id**\ (\ instance_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_instance_from_id>`
Returns the :ref:`Object<class_Object>` that corresponds to ``instance_id``. All Objects have a unique instance ID. See also :ref:`Object.get_instance_id()<class_Object_method_get_instance_id>`.
.. tabs::
.. code-tab:: gdscript
var drink = "water"
func _ready():
var id = get_instance_id()
var instance = instance_from_id(id)
print(instance.drink) # Prints "water"
.. code-tab:: csharp
public partial class MyNode : Node
{
public string Drink { get; set; } = "water";
public override void _Ready()
{
ulong id = GetInstanceId();
var instance = (MyNode)InstanceFromId(Id);
GD.Print(instance.Drink); // Prints "water"
}
}
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_inverse_lerp:
.. rst-class:: classref-method
:ref:`float<class_float>` **inverse_lerp**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_inverse_lerp>`
Devuelve un factor de interpolación o extrapolación, considerando el rango especificado en ``from`` y ``to``, y el valor interpolado especificado en ``weight``. El valor devuelto estará entre ``0.0`` y ``1.0`` si ``weight`` está entre ``from`` y ``to`` (inclusivo). Si ``weight`` está ubicado fuera de este rango, se devolverá un factor de extrapolación (valor de retorno menor que ``0.0`` o mayor que ``1.0``). Utiliza :ref:`clamp()<class_@GlobalScope_method_clamp>` sobre el resultado de :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>` si este no es el comportamiento deseado.
::
# La razón de interpolación en la llamada a "lerp()" de más abajo es 0.75.
var middle = lerp(20, 30, 0.75)
# "middle" ahora es 27.5.
# Ahora, suponemos haber olvidado la razón original y queremos obtenerla de vuelta.
var ratio = inverse_lerp(20, 30, 27.5)
# "ratio" ahora es 0.75.
Véase también :ref:`lerp()<class_@GlobalScope_method_lerp>`, el cual ejecuta la operación inversa a esta, y :ref:`remap()<class_@GlobalScope_method_remap>` para mapear una series continua de valores a otros.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_equal_approx>`
Devuelve ``true`` si ``a`` y ``b`` son aproximadamente iguales entre sí.
Aquí, "aproximadamente iguales" significa que ``a`` y ``b`` están dentro de una pequeña épsilon interna de cada uno, que se escala con la magnitud de los números.
Los valores infinitos del mismo signo se consideran iguales.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_finite:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_finite**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_finite>`
Devuelve si ``x`` es un valor finito, p. ej., si no es :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>`, infinito positivo o infinito negativo. Véase también :ref:`is_inf()<class_@GlobalScope_method_is_inf>` y :ref:`is_nan()<class_@GlobalScope_method_is_nan>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_inf:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_inf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_inf>`
Devuelve ``true`` si ``x`` es un valor de infinito (positivo o negativo). Véase también :ref:`is_finite()<class_@GlobalScope_method_is_finite>` y :ref:`is_nan()<class_@GlobalScope_method_is_nan>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_instance_id_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_instance_id_valid**\ (\ id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_is_instance_id_valid>`
Devuelve ``true`` si el Objeto que corresponde a ``id`` es valido (p.ej. si no se ha borrado de la memoria). Todos los Objetos tiene un ID de instancia único.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_instance_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_instance_valid**\ (\ instance\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_is_instance_valid>`
Devuelve ``true`` si ``instance`` es un Objeto válido (p. ej. si no ha sido borrado de la memoria).
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_nan:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_nan**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_nan>`
Devuelve ``true`` si ``x`` es un valor NaN ("Not a Number" o inválido). Este método es necesario porque :ref:`@GDScript.NAN<class_@GDScript_constant_NAN>` no se considera equivalente a sí mismo, por lo que ``x == NAN`` no sirve para comprobar si un valor es NaN.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_same:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_same**\ (\ a\: :ref:`Variant<class_Variant>`, b\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_is_same>`
Devuelve ``true``, para los tipos de valor, si ``a`` y ``b`` comparten el mismo valor. Devuelve ``true``, para los tipos de referencia, si las referencias de ``a`` y ``b`` son iguales.
::
# Vector2 es un tipo de valor
var vec2_a = Vector2(0, 0)
var vec2_b = Vector2(0, 0)
var vec2_c = Vector2(1, 1)
is_same(vec2_a, vec2_a) # true
is_same(vec2_a, vec2_b) # true
is_same(vec2_a, vec2_c) # false
# Array es un tipo de referencia
var arr_a = []
var arr_b = []
is_same(arr_a, arr_a) # true
is_same(arr_a, arr_b) # false
Estos son tipos de valores de :ref:`Variant<class_Variant>`: ``null``, :ref:`bool<class_bool>`, :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`String<class_String>`, :ref:`StringName<class_StringName>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`, :ref:`Rect2<class_Rect2>`, :ref:`Rect2i<class_Rect2i>`, :ref:`Transform2D<class_Transform2D>`, :ref:`Transform3D<class_Transform3D>`, :ref:`Plane<class_Plane>`, :ref:`Quaternion<class_Quaternion>`, :ref:`AABB<class_AABB>`, :ref:`Basis<class_Basis>`, :ref:`Projection<class_Projection>`, :ref:`Color<class_Color>`, :ref:`NodePath<class_NodePath>`, :ref:`RID<class_RID>`, :ref:`Callable<class_Callable>` and :ref:`Signal<class_Signal>`.
Estas son :ref:`Variant<class_Variant>` de tipo de referencia: :ref:`Object<class_Object>`, :ref:`Dictionary<class_Dictionary>`, :ref:`Array<class_Array>`, :ref:`PackedByteArray<class_PackedByteArray>`, :ref:`PackedInt32Array<class_PackedInt32Array>`, :ref:`PackedInt64Array<class_PackedInt64Array>`, :ref:`PackedFloat32Array<class_PackedFloat32Array>`, :ref:`PackedFloat64Array<class_PackedFloat64Array>`, :ref:`PackedStringArray<class_PackedStringArray>`, :ref:`PackedVector2Array<class_PackedVector2Array>`, :ref:`PackedVector3Array<class_PackedVector3Array>`,\ :ref:`PackedVector4Array<class_PackedVector4Array>` y :ref:`PackedColorArray<class_PackedColorArray>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_is_zero_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_zero_approx**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_is_zero_approx>`
Devuelve ``true`` si ``x`` es cero o casi cero. La comparación se hace usando un calculo de tolerancia con un épsilon pequeño interno.
Este método es más rápido que usar :ref:`is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` con un valor como cero.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_lerp:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **lerp**\ (\ from\: :ref:`Variant<class_Variant>`, to\: :ref:`Variant<class_Variant>`, weight\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_lerp>`
Interpola linealmente entre dos valores por un valor definido por ``weight``. Para hacer la interpolación ``weight`` debe estar en el rango de los valores ``0.0`` y ``1.0`` (inclusivo). No obstante, valores fuera de este rango también están permitidos y pueden usarse para hacer una *extrapolación*. Si este no es el comportamiento deseado, usa :ref:`clampf()<class_@GlobalScope_method_clampf>` para limitar a ``weight``.
Tanto ``from`` como ``to`` deben de ser del mismo tipo. Tipos soportados: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector4<class_Vector4>`, :ref:`Color<class_Color>`, :ref:`Quaternion<class_Quaternion>`, :ref:`Basis<class_Basis>`, :ref:`Transform2D<class_Transform2D>`, :ref:`Transform3D<class_Transform3D>`.
::
lerp(0, 4, 0.75) # Devuelve 3.0
Véase también: :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`, que realiza la operación inversa. Para hacer una interpolación de tipo eased con :ref:`lerp()<class_@GlobalScope_method_lerp>`, combínalo con :ref:`ease()<class_@GlobalScope_method_ease>` o :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`. Véase también: :ref:`remap()<class_@GlobalScope_method_remap>` para mapear un serie continua de valores a otra.
\ **Nota:** Para mejor seguridad con tipos usa :ref:`lerpf()<class_@GlobalScope_method_lerpf>`, :ref:`Vector2.lerp()<class_Vector2_method_lerp>`, :ref:`Vector3.lerp()<class_Vector3_method_lerp>`, :ref:`Vector4.lerp()<class_Vector4_method_lerp>`, :ref:`Color.lerp()<class_Color_method_lerp>`, :ref:`Quaternion.slerp()<class_Quaternion_method_slerp>`, :ref:`Basis.slerp()<class_Basis_method_slerp>`, :ref:`Transform2D.interpolate_with()<class_Transform2D_method_interpolate_with>`, o :ref:`Transform3D.interpolate_with()<class_Transform3D_method_interpolate_with>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_lerp_angle:
.. rst-class:: classref-method
:ref:`float<class_float>` **lerp_angle**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_lerp_angle>`
Interpola linealmente entre dos ángulos (en radianes) por un valor ``weight`` entre 0.0 y 1.0.
Similar a :ref:`lerp()<class_@GlobalScope_method_lerp>`, pero interpola correctamente cuando los ángulos se envuelven alrededor de :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>`. Para realizar una interpolación suavizada con :ref:`lerp_angle()<class_@GlobalScope_method_lerp_angle>`, combínala con :ref:`ease()<class_@GlobalScope_method_ease>` o :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`.
::
extends Sprite
var elapsed = 0.0
func _process(delta):
var min_angle = deg_to_rad(0.0)
var max_angle = deg_to_rad(90.0)
rotation = lerp_angle(min_angle, max_angle, elapsed)
elapsed += delta
\ **Nota:** Esta función interpola a través de la ruta más corta entre ``from`` y ``to``. Sin embargo, cuando estos dos ángulos están aproximadamente a ``PI + k * TAU`` de distancia para cualquier ``k`` entero, no es obvio de qué manera se interpolan debido a errores de precisión de punto flotante. Por ejemplo, ``lerp_angle(0, PI, weight)`` interpola en sentido antihorario, mientras que ``lerp_angle(0, PI + 5 * TAU, weight)`` interpola en el sentido de las agujas del reloj.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_lerpf:
.. rst-class:: classref-method
:ref:`float<class_float>` **lerpf**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, weight\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_lerpf>`
Interpola linealmente entre dos valores por el factor definido en ``weight``. Para realizar la interpolación, ``weight`` debe estar entre ``0.0`` y ``1.0`` (inclusive). Sin embargo, se permiten valores fuera de este rango y se pueden usar para realizar *extrapolación*. Si esto no es deseado, usa :ref:`clampf()<class_@GlobalScope_method_clampf>` en el resultado de esta función.
::
lerpf(0, 4, 0.75) # Devuelve 3.0
Véase también :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>` que realiza la operación inversa. Para realizar una interpolación suavizada con :ref:`lerp()<class_@GlobalScope_method_lerp>`, combínala con :ref:`ease()<class_@GlobalScope_method_ease>` o :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_linear_to_db:
.. rst-class:: classref-method
:ref:`float<class_float>` **linear_to_db**\ (\ lin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_linear_to_db>`
Convierte energía lineal a decibelios (audio). Dado que el volumen no es normalmente lineal, esto se puede usar para implementar controles deslizantes de volumen que se comporten como se espera.
\ **Ejemplo:** Cambia el volumen del bus maestro a través de un nodo :ref:`Slider<class_Slider>`, que varía de ``0.0`` a ``1.0``:
::
AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear_to_db($Slider.value))
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_log:
.. rst-class:: classref-method
:ref:`float<class_float>` **log**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_log>`
Devuelve el logaritmo natural de ``x`` `natural logarithm <https://en.wikipedia.org/wiki/Natural_logarithm>`__ (base `[i]e[/i] <https://en.wikipedia.org/wiki/E_(mathematical_constant)>`__, con *e* siendo aproximadamente 2.71828). Esta es la cantidad de tiempo necesaria para alcanzar un cierto nivel de crecimiento continuo.
\ **Nota:** Esto no es lo mismo que la función "log" de la mayoría de las calculadoras, que utiliza un logaritmo de base 10. Para usar el logaritmo de base 10, usa ``log(x) / log(10)``.
::
log(10) # Devuelve 2.302585
\ **Nota:** El logaritmo de ``0`` devuelve ``-inf``, mientras que los valores negativos devuelven ``-nan``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_max:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **max**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_max>`
Devuelve el máximo de los valores numéricos dados. Esta función puede tomar cualquier número de argumentos.
::
max(1, 7, 3, -6, 5) # Devuelve 7
\ **Nota:** Al usarse en vectores, *no* calculará el máximo por componente y elegirá el valor más grande cuando se compare utilizando ``x < y``. Para realizar el máximo por componente, use :ref:`Vector2.max()<class_Vector2_method_max>`, :ref:`Vector2i.max()<class_Vector2i_method_max>`, :ref:`Vector3.max()<class_Vector3_method_max>`, :ref:`Vector3i.max()<class_Vector3i_method_max>`, :ref:`Vector4.max()<class_Vector4_method_max>` y :ref:`Vector4i.max()<class_Vector4i_method_max>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_maxf:
.. rst-class:: classref-method
:ref:`float<class_float>` **maxf**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_maxf>`
Devuelve el máximo de dos valores :ref:`float<class_float>`.
::
maxf(3.6, 24) # Devuelve 24.0
maxf(-3.99, -4) # Devuelve -3.99
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_maxi:
.. rst-class:: classref-method
:ref:`int<class_int>` **maxi**\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_maxi>`
Devuelve el máximo de dos valores :ref:`int<class_int>`.
::
maxi(1, 2) # Devuelve 2
maxi(-3, -4) # Devuelve -3
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_min:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **min**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_min>`
Devuelve el mínimo de los valores numéricos dados. Esta función puede recibir cualquier número de argumentos.
::
min(1, 7, 3, -6, 5) # Devuelve -6
\ **Nota:** Al usarlo en vectores, *no* calculará el mínimo de cada componente y elegirá el valor más pequeño cuando se compare utilizando ``x < y``. Para realizar el mínimo de cada componente, use :ref:`Vector2.min()<class_Vector2_method_min>`, :ref:`Vector2i.min()<class_Vector2i_method_min>`, :ref:`Vector3.min()<class_Vector3_method_min>`, :ref:`Vector3i.min()<class_Vector3i_method_min>`, :ref:`Vector4.min()<class_Vector4_method_min>` y :ref:`Vector4i.min()<class_Vector4i_method_min>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_minf:
.. rst-class:: classref-method
:ref:`float<class_float>` **minf**\ (\ a\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_minf>`
Devuelve el mínimo de dos valores :ref:`float<class_float>`.
::
minf(3.6, 24) # Devuelve 3.6
min(-3.99, -4) # Devuelve -4
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_mini:
.. rst-class:: classref-method
:ref:`int<class_int>` **mini**\ (\ a\: :ref:`int<class_int>`, b\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_mini>`
Devuelve el mínimo de dos valores :ref:`int<class_int>`.
::
mini(1, 2) # Devuelve 1
mini(-3, -4) # Devuelve -4
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_move_toward:
.. rst-class:: classref-method
:ref:`float<class_float>` **move_toward**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_move_toward>`
Mueve ``from`` hacia ``to`` por el valor ``delta``. No se pasara del valor ``to``\
Usa un valor negativo de ``delta`` para mover el valor en sentido opuesto.
::
move_toward(5, 10, 4) # Devuelve 9
move_toward(10, 5, 4) # Devuelve 6
move_toward(5, 10, 9) # Devuelve 10
move_toward(10, 5, -1.5) # Devuelve 11.5
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_nearest_po2:
.. rst-class:: classref-method
:ref:`int<class_int>` **nearest_po2**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_nearest_po2>`
Devuelve la potencia entera más pequeña de 2 que es mayor o igual que ``value``.
::
nearest_po2(3) # Devuelve 4
nearest_po2(4) # Devuelve 4
nearest_po2(5) # Devuelve 8
nearest_po2(0) # Devuelve 0 (esto puede no ser lo esperado)
nearest_po2(-1) # Devuelve 0 (esto puede no ser lo esperado)
\ **Advertencia:** Debido a su implementación, este método devuelve ``0`` en lugar de ``1`` para valores menores o iguales a ``0``, con una excepción para ``value`` siendo el entero negativo de 64 bits más pequeño (``-9223372036854775808``) en cuyo caso el ``value`` se devuelve sin cambios.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_pingpong:
.. rst-class:: classref-method
:ref:`float<class_float>` **pingpong**\ (\ value\: :ref:`float<class_float>`, length\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_pingpong>`
Envuelve a ``value`` entre ``0`` y ``length``. Si el límite es alcanzado, el siguiente valor que la función devuelva es reducido hacia ``0`` o incrementado hacia ``length`` (como una ola triangular). Si ``length`` es menor que cero, se convierte en positivo.
::
pingpong(-3.0, 3.0) # Devuelve 3.0
pingpong(-2.0, 3.0) # Devuelve 2.0
pingpong(-1.0, 3.0) # Devuelve 1.0
pingpong(0.0, 3.0) # Devuelve 0.0
pingpong(1.0, 3.0) # Devuelve 1.0
pingpong(2.0, 3.0) # Devuelve 2.0
pingpong(3.0, 3.0) # Devuelve 3.0
pingpong(4.0, 3.0) # Devuelve 2.0
pingpong(5.0, 3.0) # Devuelve 1.0
pingpong(6.0, 3.0) # Devuelve 0.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_posmod:
.. rst-class:: classref-method
:ref:`int<class_int>` **posmod**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_posmod>`
Devuelve el módulo entero de ``x`` dividido por ``y`` que se ajusta igualmente en positivo y negativo.
::
print("#(i) (i % 3) (posmod(i, 3))")
for i in range(-3, 4):
print("%2d %2d | %2d" % [i, i % 3, posmod(i, 3)])
Imprime:
.. code:: text
(i) (i % 3) (posmod(i, 3))
-3 0 | 0
-2 -2 | 1
-1 -1 | 2
0 0 | 0
1 1 | 1
2 2 | 2
3 0 | 0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_pow:
.. rst-class:: classref-method
:ref:`float<class_float>` **pow**\ (\ base\: :ref:`float<class_float>`, exp\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_pow>`
Devuelve el resultado de ``base`` elevado a la potencia de ``exp``.
En GDScript, esto es el equivalente al operador ``**``.
::
pow(2, 5) # Devuelve 32.0
pow(4, 1.5) # Devuelve 8.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_print:
.. rst-class:: classref-method
|void| **print**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print>`
Convierte uno o más argumentos de cualquier tipo a string de la mejor manera posible y los imprime en la consola.
.. tabs::
.. code-tab:: gdscript
var a = [1, 2, 3]
print("a", "b", a) # Prints "ab[1, 2, 3]"
.. code-tab:: csharp
Godot.Collections.Array a = [1, 2, 3];
GD.Print("a", "b", a); // Prints "ab[1, 2, 3]"
\ **Note:** Considera usar :ref:`push_error()<class_@GlobalScope_method_push_error>` y :ref:`push_warning()<class_@GlobalScope_method_push_warning>` para imprimir mensajes de error y advertencia en lugar de :ref:`print()<class_@GlobalScope_method_print>` o :ref:`print_rich()<class_@GlobalScope_method_print_rich>`. Esto los distingue de los mensajes de impresión utilizados para fines de depuración, mientras que también muestra un seguimiento de la pila cuando se imprime un error o una advertencia. Véase también :ref:`Engine.print_to_stdout<class_Engine_property_print_to_stdout>` y :ref:`ProjectSettings.application/run/disable_stdout<class_ProjectSettings_property_application/run/disable_stdout>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_print_rich:
.. rst-class:: classref-method
|void| **print_rich**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print_rich>`
Convierte uno o más argumentos de cualquier tipo en una string de la mejor manera posible y los imprime en la consola.
Se admiten las siguientes etiquetas BBCode: ``b``, ``i``, ``u``, ``s``, ``indent``, ``code``, ``url``, ``center``, ``right``, ``color``, ``bgcolor``, ``fgcolor``.
Las etiquetas URL solo admiten URL envueltas por una etiqueta URL, no así URL con un título diferente.
Al imprimir en la salida estándar, el subconjunto compatible de BBCode se convierte en códigos de escape ANSI para que el emulador de terminal los muestre. La compatibilidad con los códigos de escape ANSI varía entre los emuladores de terminal, especialmente para cursiva y tachado. En la salida estándar, ``code`` se representa con texto tenue pero sin ningún cambio de fuente. Las etiquetas no compatibles se dejan tal como están en la salida estándar.
.. tabs::
.. code-tab:: gdscript
print_rich("[color=green][b]¡Hola mundo![/b][/color]") # Imprime "¡Hola mundo!" en verde con una fuente en negrita
.. code-tab:: csharp
GD.PrintRich("[color=green][b]¡Hola mundo![/b][/color]"); // Imprime "¡Hola mundo!" en verde con una fuente en negrita
\ **Nota:** Considera usar :ref:`push_error()<class_@GlobalScope_method_push_error>` y :ref:`push_warning()<class_@GlobalScope_method_push_warning>` para imprimir mensajes de error y advertencia en lugar de :ref:`print()<class_@GlobalScope_method_print>` o :ref:`print_rich()<class_@GlobalScope_method_print_rich>`. Esto los distingue de los mensajes de impresión utilizados para fines de depuración, mientras que también muestra un seguimiento de la pila cuando se imprime un error o una advertencia.
\ **Nota:** La salida que se muestra en el editor admite etiquetas ``[url=address]texto[/url]`` en las que se puede hacer clic. El valor ``address`` de la etiqueta ``[url]`` es manejado por :ref:`OS.shell_open()<class_OS_method_shell_open>` cuando se hace clic en ella.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_print_verbose:
.. rst-class:: classref-method
|void| **print_verbose**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_print_verbose>`
Si el modo detallado (verbose mode) está habilitado (:ref:`OS.is_stdout_verbose()<class_OS_method_is_stdout_verbose>` devolverá ``true``), convierte uno o más argumentos de cualquier tipo en una string de la mejor manera posible y los imprime en la consola.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_printerr:
.. rst-class:: classref-method
|void| **printerr**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printerr>`
Imprime uno o más argumentos como strings de la mejor manera posible a la línea de error estándar.
.. tabs::
.. code-tab:: gdscript
printerr("Imprime a stderr")
.. code-tab:: csharp
GD.PrintErr("Imprime a stderr");
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_printraw:
.. rst-class:: classref-method
|void| **printraw**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printraw>`
Imprime uno o más argumentos como strings de la mejor manera posible en la terminal del SO. A diferencia de :ref:`print()<class_@GlobalScope_method_print>`, no se añade automáticamente una nueva línea al final.
\ **Nota:** El terminal del SO *no* es el mismo que el dock de salida del editor. La salida enviada al terminal del SO se puede ver al ejecutar Godot desde un terminal. En Windows, esto requiere el uso del ejecutable ``console.exe``.
.. tabs::
.. code-tab:: gdscript
# Imprime "ABC" en la terminal.
printraw("A")
printraw("B")
printraw("C")
.. code-tab:: csharp
// Imprime "ABC" en la terminal.
GD.PrintRaw("A");
GD.PrintRaw("B");
GD.PrintRaw("C");
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_prints:
.. rst-class:: classref-method
|void| **prints**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_prints>`
Imprime uno o más argumentos en la consola con un espacio entre cada argumento.
.. tabs::
.. code-tab:: gdscript
prints("A", "B", "C") # Imprime "A B C"
.. code-tab:: csharp
GD.PrintS("A","B","C"); // Imprime "A B C"
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_printt:
.. rst-class:: classref-method
|void| **printt**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_printt>`
Imprime uno o más argumentos en la consola con una tabulación entre cada argumento.
.. tabs::
.. code-tab:: gdscript
printt("A", "B", "C") # Imprime "A B C"
.. code-tab:: csharp
GD.PrintT("A", "B", "C"); // Imprime "A B C"
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_push_error:
.. rst-class:: classref-method
|void| **push_error**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_push_error>`
Envía un mensaje de error al depurador incorporado de Godot y a la terminal del sistema operativo.
.. tabs::
.. code-tab:: gdscript
push_error("error de prueba") # Imprime "error de prueba" en el depurador y la terminal como un error.
.. code-tab:: csharp
GD.PushError("error de prueba"); // Imprime "error de prueba" en el depurador y la terminal como un error.
\ **Nota:** Esta función no pausa la ejecución del proyecto. Para imprimir un mensaje de error y pausar la ejecución del proyecto en compilaciones de depuración, usa ``assert(false, "test error")`` en su lugar.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_push_warning:
.. rst-class:: classref-method
|void| **push_warning**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_push_warning>`
Envía un mensaje de advertencia al depurador incorporado de Godot y a la terminal del sistema operativo.
.. tabs::
.. code-tab:: gdscript
push_warning("test warning") # Imprime "test warning" en depurador y la terminal como una advertencia.
.. code-tab:: csharp
GD.PushWarning("test warning"); // Imprime "test warning" en depurador y la terminal como una advertencia.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_rad_to_deg:
.. rst-class:: classref-method
:ref:`float<class_float>` **rad_to_deg**\ (\ rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_rad_to_deg>`
Convierte un ángulo expresado en radianes a grados.
::
rad_to_deg(0.523599) # Devuelve 30.0
rad_to_deg(PI) # Devuelve 180
rad_to_deg(PI * 2) # Devuelve 360
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_rand_from_seed:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **rand_from_seed**\ (\ seed\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_rand_from_seed>`
Dado un ``seed``, devuelve un :ref:`PackedInt64Array<class_PackedInt64Array>` de tamaño ``2``, donde su primer elemento es el valor aleatorio :ref:`int<class_int>`, y el segundo elemento es el mismo que ``seed``. Pasar el mismo ``seed`` devuelve consistentemente el mismo array.
\ **Nota:** "Seed" aquí se refiere al estado interno del generador de números pseudoaleatorios, actualmente implementado como un entero de 64 bits.
::
var a = rand_from_seed(4)
print(a[0]) # Imprime 2879024997
print(a[1]) # Imprime 4
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randf:
.. rst-class:: classref-method
:ref:`float<class_float>` **randf**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randf>`
Devuelve un valor de punto flotante aleatorio entre ``0.0`` y ``1.0`` (inclusive).
.. tabs::
.. code-tab:: gdscript
randf() # Devuelve p. ej. 0.375671
.. code-tab:: csharp
GD.Randf(); // Devuelve p. ej. 0.375671
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randf_range:
.. rst-class:: classref-method
:ref:`float<class_float>` **randf_range**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_randf_range>`
Devuelve un valor de punto flotante aleatorio entre ``from`` y ``to`` (inclusive).
.. tabs::
.. code-tab:: gdscript
randf_range(0, 20.5) # Devuelve p. ej. 7.45315
randf_range(-10, 10) # Devuelve p.ej. -3.844535
.. code-tab:: csharp
GD.RandRange(0.0, 20.5); // Devuelve p. ej. 7.45315
GD.RandRange(-10.0, 10.0); // Devuelve p. ej. -3.844535
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randfn:
.. rst-class:: classref-method
:ref:`float<class_float>` **randfn**\ (\ mean\: :ref:`float<class_float>`, deviation\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_randfn>`
Genera un número pseudoaleatorio `distribuido normalmente <https://en.wikipedia.org/wiki/Normal_distribution>`__, utilizando la transformación Box-Muller con el ``mean`` especificado y una ``deviation`` estándar. Esto también se denomina como distribución gaussiana.
\ **Nota:** Este método usa el algoritmo `Box-Muller <https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform>`__.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randi:
.. rst-class:: classref-method
:ref:`int<class_int>` **randi**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randi>`
Devuelve un entero aleatorio sin signo de 32 bits. Utiliza el residuo para obtener un valor aleatorio en el intervalo ``[0, N - 1]`` (donde N es menor que 2^32).
.. tabs::
.. code-tab:: gdscript
randi() # Devuelve un entero aleatorio entre 0 y 2^32 - 1.
randi() % 20 # Devuelve un entero aleatorio entre 0 y 19.
randi() % 100 # Devuelve un entero aleatorio entre 0 y 99.
randi() % 100 + 1 # Devuelve un entero aleatoria entre 1 y 100
.. code-tab:: csharp
GD.Randi(); // Devuelve un entero aleatorio entre 0 y 2^32 - 1.
GD.Randi() % 20; // Devuelve un entero aleatorio entre 0 y 19.
GD.Randi() % 100; // Devuelve un entero aleatorio entre 0 y 99.
GD.Randi() % 100 + 1; // Devuelve un entero aleatoria entre 1 y 100
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randi_range:
.. rst-class:: classref-method
:ref:`int<class_int>` **randi_range**\ (\ from\: :ref:`int<class_int>`, to\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_randi_range>`
Devuelve un entero aleatorio con signo de 32 bits en el rango de ``from`` hasta ``to`` (inclusivo). Si ``to`` es menor que ``from``, se intercambian.
.. tabs::
.. code-tab:: gdscript
randi_range(0, 1) # Devuelve el valor 0 o 1
randi_range(-10, 1000) # Devuelve un entero aleatorio entre -10 y 1000
.. code-tab:: csharp
GD.RandRange(0, 1); // Devuelve el valor 0 o 1
GD.RandRange(-10, 1000); // Devuelve un entero aleatorio entre -10 y 1000
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_randomize:
.. rst-class:: classref-method
|void| **randomize**\ (\ ) :ref:`🔗<class_@GlobalScope_method_randomize>`
Aleatorizar la semilla (o el estado interno) del generador de números aleatorios. Es una implementación actual que utiliza un numero basado en el tiempo del dispositivo.
\ **Nota:** Esta función es llamada automáticamente cuando se ejecuta el proyecto. Si se necesita arreglar la semilla para mas consistencia o reproducir resultados, usa :ref:`seed()<class_@GlobalScope_method_seed>` para inicializar el generador de números aleatorios.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_remap:
.. rst-class:: classref-method
:ref:`float<class_float>` **remap**\ (\ value\: :ref:`float<class_float>`, istart\: :ref:`float<class_float>`, istop\: :ref:`float<class_float>`, ostart\: :ref:`float<class_float>`, ostop\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_remap>`
Mapea un ``value`` en un rango de ``[istart, istop]`` a ``[ostart, ostop]``. Véase también :ref:`lerp()<class_@GlobalScope_method_lerp>` y :ref:`inverse_lerp()<class_@GlobalScope_method_inverse_lerp>`. Si ``value`` esta afuera ``[istart, istop]``, entonces el valor resultante también estara fuera ``[ostart, ostop]``. Si esto no es lo deseado, use :ref:`clamp()<class_@GlobalScope_method_clamp>` en el resultado de esta función.
::
remap(75, 0, 100, -1, 1) #Devuelve 0.5
Para casos mas complejos en donde se requieran multiples rangos, considera utilizar :ref:`Curve<class_Curve>` o :ref:`Gradient<class_Gradient>` en su lugar.
\ **Nota:** Si ``istart == istop``, el valor devuelto es indefinido (probablemente NaN, INF, o -INF).
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_rid_allocate_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **rid_allocate_id**\ (\ ) :ref:`🔗<class_@GlobalScope_method_rid_allocate_id>`
Asigna un ID único que puede se usado por la implementación para la construcción de un RID. Esto se utiliza principalmente desde extensiones nativas para implementar en servidores.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_rid_from_int64:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **rid_from_int64**\ (\ base\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_rid_from_int64>`
Crea un RID a partir de un ``base``. Esto es usado principalmente por extensiones nativas para la constricción de servidores.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_rotate_toward:
.. rst-class:: classref-method
:ref:`float<class_float>` **rotate_toward**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, delta\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_rotate_toward>`
Gira ``from`` hacia ``to`` en la cantidad de ``delta``. No pasará de ``to``.
Similar a :ref:`move_toward()<class_@GlobalScope_method_move_toward>`, pero se interpola correctamente cuando los ángulos se ajustan a :ref:`@GDScript.TAU<class_@GDScript_constant_TAU>`.
Si ``delta`` es negativo, esta función se alejará de ``to``, hacia el ángulo opuesto y no pasará del ángulo opuesto.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_round:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **round**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_round>`
Redondea ``x`` al número entero más cercano, con los casos intermedios redondeados a partir de 0. Datos soportados: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
round(2.4) # Devuelve 2
round(2.5) # Devuelve 3
round(2.6) # Devuelve 3
Véase también :ref:`floor()<class_@GlobalScope_method_floor>`, :ref:`ceil()<class_@GlobalScope_method_ceil>`, y :ref:`snapped()<class_@GlobalScope_method_snapped>`.
\ **Nota:** Para un mejor tipado seguro, use :ref:`roundf()<class_@GlobalScope_method_roundf>`, :ref:`roundi()<class_@GlobalScope_method_roundi>`, :ref:`Vector2.round()<class_Vector2_method_round>`, :ref:`Vector3.round()<class_Vector3_method_round>`, o :ref:`Vector4.round()<class_Vector4_method_round>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_roundf:
.. rst-class:: classref-method
:ref:`float<class_float>` **roundf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_roundf>`
Redondea ``x`` al numero entero mas cercano, con los casos intermedios redondeados a partir de 0.
Es una version de tipado seguro del :ref:`round()<class_@GlobalScope_method_round>` , retorna un :ref:`float<class_float>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_roundi:
.. rst-class:: classref-method
:ref:`int<class_int>` **roundi**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_roundi>`
Redondea ``x`` al numero entero mas cercano, con los casos intermedios redondeados a partir de 0.
Es una version de tipado seguro del :ref:`round()<class_@GlobalScope_method_round>` , retorna un :ref:`int<class_int>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_seed:
.. rst-class:: classref-method
|void| **seed**\ (\ base\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_seed>`
Establece la semilla para el generador de números aleatorios en ``base``. Configurar la semilla manualmente puede garantizar resultados consistentes y repetibles para la mayoría de los casos aleatorios. functions.
.. tabs::
.. code-tab:: gdscript
var my_seed = "Godot Rocks".hash()
seed(my_seed)
var a = randf() + randi()
seed(my_seed)
var b = randf() + randi()
# a and b are now identical
.. code-tab:: csharp
ulong mySeed = (ulong)GD.Hash("Godot Rocks");
GD.Seed(mySeed);
var a = GD.Randf() + GD.Randi();
GD.Seed(mySeed);
var b = GD.Randf() + GD.Randi();
// a and b are now identical
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_sign:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **sign**\ (\ x\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_sign>`
Devuelve el mismo :ref:`Variant<class_Variant>` como ``x``, dando ``-1`` para valores negativos, ``1`` para valores positivos y ``0`` para cero. Para los valores ``NaN`` (No es un Numero) devuelve cero.
Tipos soportados :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
sign(-6.0) # Devuelve-1
sign(0.0) # Devuelve 0
sign(6.0) # Devuelve 1
sign(NAN) # Devuelve 0
sign(Vector3(-6.0, 0.0, 6.0)) # Devuelve (-1, 0, 1)
\ **Nota** Para mejor seguridad en los tipos, use :ref:`signf()<class_@GlobalScope_method_signf>`, :ref:`signi()<class_@GlobalScope_method_signi>`, :ref:`Vector2.sign()<class_Vector2_method_sign>`, :ref:`Vector2i.sign()<class_Vector2i_method_sign>`, :ref:`Vector3.sign()<class_Vector3_method_sign>`, :ref:`Vector3i.sign()<class_Vector3i_method_sign>`, :ref:`Vector4.sign()<class_Vector4_method_sign>`, o :ref:`Vector4i.sign()<class_Vector4i_method_sign>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_signf:
.. rst-class:: classref-method
:ref:`float<class_float>` **signf**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_signf>`
Devuelve ``-1.0`` si ``x`` es negativo, ``1.0`` si es ``x`` positivo y ``0.0`` si ``x`` es igual a cero. Para valores ``nan`` de ``x``, devuelve 0.0.
::
sign(-6.5) # Devuelve -1.0
sign(0.0) # Devuelve 0.0
sign(6.5) # Devuelve 1.0
signf(NAN) # Devuelve 0.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_signi:
.. rst-class:: classref-method
:ref:`int<class_int>` **signi**\ (\ x\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_signi>`
Devuelve ``-1`` si ``x`` es un valor negativo, ``1`` si ``x`` es positivo y ``0`` cuando ``x`` es igual a cero.
::
sign(-6) # Devuelve -1
sign(0) # Devuelve 0
sign(6) # Devuelve 1
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_sin:
.. rst-class:: classref-method
:ref:`float<class_float>` **sin**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sin>`
Devuelve el seno de un angulo ``angle_rad`` en radianes.
::
sin(0.523599) # Devuelve 0.5
sin(deg_to_rad(90)) # Devuelve 1.0
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_sinh:
.. rst-class:: classref-method
:ref:`float<class_float>` **sinh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sinh>`
Devuelve el seno hiperbolico de ``x``.
::
var a = log(2.0) # Devuelve 0.693147
sinh(a) # Devuelve 0.75
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_smoothstep:
.. rst-class:: classref-method
:ref:`float<class_float>` **smoothstep**\ (\ from\: :ref:`float<class_float>`, to\: :ref:`float<class_float>`, x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_smoothstep>`
Devuelve una interpolación cúbica de Hermite suave entre ``0`` y ``1``.
Para rangos positivos (cuando ``from <= to``) el valor de retorno es ``0`` cuando ``x <= from``, y ``1`` cuando ``x >= to``. Si ``x`` se encuentra entre ``from`` y ``to``, el valor devuelto sigue una curva en forma de S que realiza una transición suave de ``0`` a ``1``.
Para rangos negativos (cuando ``from > to``) la función se refleja y devuelve ``1`` cuando ``x <= to`` y ``0`` cuando ``x >= from``.
Esta curva en forma de S es el interpolador cúbico de Hermite, dado por ``f(y) = 3*y^2 - 2*y^3`` donde ``y = (x-from) / (to-from)``.
::
smoothstep(0, 2, -5.0) # Devuelve 0.0
smoothstep(0, 2, 0.5) # Devuelve 0.15625
smoothstep(0, 2, 1.0) # Devuelve 0.5
smoothstep(0, 2, 2.0) # Devuelve 1.0
Comparado con :ref:`ease()<class_@GlobalScope_method_ease>` con un valor de curva de ``-1.6521``, :ref:`smoothstep()<class_@GlobalScope_method_smoothstep>` devuelve la curva más suave posible sin cambios repentinos en la derivada. Si necesitas realizar transiciones más avanzadas, usa :ref:`Tween<class_Tween>` o :ref:`AnimationPlayer<class_AnimationPlayer>`.
\ `Comparación entre los valores de retorno de smoothstep() y ease(x, -1.6521) <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_ease_comparison.png>`__\
\ `Valores de retorno de Smoothstep() con rangos positivos, cero y negativos <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/smoothstep_range.webp>`__
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_snapped:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **snapped**\ (\ x\: :ref:`Variant<class_Variant>`, step\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_snapped>`
Devuelve el múltiplo de ``step`` que está más cerca de ``x``. Esto también se puede usar para redondear un número de punto flotante a un número arbitrario de decimales.
El valor devuelto es del mismo tipo de :ref:`Variant<class_Variant>` que ``step``. Tipos compatibles: :ref:`int<class_int>`, :ref:`float<class_float>`, :ref:`Vector2<class_Vector2>`, :ref:`Vector2i<class_Vector2i>`, :ref:`Vector3<class_Vector3>`, :ref:`Vector3i<class_Vector3i>`, :ref:`Vector4<class_Vector4>`, :ref:`Vector4i<class_Vector4i>`.
::
snapped(100, 32) # Devuelve 96
snapped(3.14159, 0.01) # Devuelve 3.14
snapped(Vector2(34, 70), Vector2(8, 8)) # Devuelve (32, 72)
Véase también :ref:`ceil()<class_@GlobalScope_method_ceil>`, :ref:`floor()<class_@GlobalScope_method_floor>` y :ref:`round()<class_@GlobalScope_method_round>`.
\ **Nota:** Para una mejor seguridad de tipos, usa :ref:`snappedf()<class_@GlobalScope_method_snappedf>`, :ref:`snappedi()<class_@GlobalScope_method_snappedi>`, :ref:`Vector2.snapped()<class_Vector2_method_snapped>`, :ref:`Vector2i.snapped()<class_Vector2i_method_snapped>`, :ref:`Vector3.snapped()<class_Vector3_method_snapped>`, :ref:`Vector3i.snapped()<class_Vector3i_method_snapped>`, :ref:`Vector4.snapped()<class_Vector4_method_snapped>` o :ref:`Vector4i.snapped()<class_Vector4i_method_snapped>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_snappedf:
.. rst-class:: classref-method
:ref:`float<class_float>` **snappedf**\ (\ x\: :ref:`float<class_float>`, step\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_snappedf>`
Devuelve el múltiplo de ``step`` que está más cerca de ``x``. Esto también se puede usar para redondear un número de punto flotante a un número arbitrario de decimales.
Una versión con seguridad de tipos de :ref:`snapped()<class_@GlobalScope_method_snapped>`, que devuelve un :ref:`float<class_float>`.
::
snappedf(32.0, 2.5) # Devuelve 32.5
snappedf(3.14159, 0.01) # Devuelve 3.14
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_snappedi:
.. rst-class:: classref-method
:ref:`int<class_int>` **snappedi**\ (\ x\: :ref:`float<class_float>`, step\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_snappedi>`
Devuelve el múltiplo de ``step`` que está más cerca de ``x``.
Una versión con seguridad de tipos de :ref:`snapped()<class_@GlobalScope_method_snapped>`, que devuelve un :ref:`int<class_int>`.
::
snappedi(53, 16) # Devuelve 48
snappedi(4096, 100) # Devuelve 4100
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_sqrt:
.. rst-class:: classref-method
:ref:`float<class_float>` **sqrt**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_sqrt>`
Devuelve la raíz cuadrada de ``x``, donde ``x`` es un número no negativo.
::
sqrt(9) # Devuelve 3
sqrt(10.24) # Devuelve 3.2
sqrt(-1) # Devuelve NaN
\ **Nota:** Los valores negativos de ``x`` devuelven NaN ("Not a Number", No es un número). En C#, si necesitas entradas negativas, usa ``System.Numerics.Complex``.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_step_decimals:
.. rst-class:: classref-method
:ref:`int<class_int>` **step_decimals**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_step_decimals>`
Devuelve la posición del primer dígito distinto de cero después de la coma decimal. Ten en cuenta que el valor de retorno máximo es 10, lo cual es una decisión de diseño en la implementación.
::
var n = step_decimals(5) # n es 0
n = step_decimals(1.0005) # n es 4
n = step_decimals(0.000000005) # n es 9
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_str:
.. rst-class:: classref-method
:ref:`String<class_String>` **str**\ (\ ...\ ) |vararg| :ref:`🔗<class_@GlobalScope_method_str>`
Convierte uno o más argumentos de cualquier tipo :ref:`Variant<class_Variant>` a un :ref:`String<class_String>` de la mejor manera posible.
::
var a = [10, 20, 30]
var b = str(a)
print(len(a)) # Imprime 3 (el número de elementos en el array).
print(len(b)) # Imprime 12 (la longitud de la string "[10, 20, 30]").
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_str_to_var:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **str_to_var**\ (\ string\: :ref:`String<class_String>`\ ) :ref:`🔗<class_@GlobalScope_method_str_to_var>`
Convierte una ``string`` formateada que fue devuelta por :ref:`var_to_str()<class_@GlobalScope_method_var_to_str>` al :ref:`Variant<class_Variant>` original.
.. tabs::
.. code-tab:: gdscript
var data = '{ "a": 1, "b": 2 }' # data es un String
var dict = str_to_var(data) # dict es un Dictionary
print(dict["a"]) # Imprime 1
.. code-tab:: csharp
string data = "{ \"a\": 1, \"b\": 2 }"; // data es una string
var dict = GD.StrToVar(data).AsGodotDictionary(); // dict es un Dictionary
GD.Print(dict["a"]); // Imprime 1
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_tan:
.. rst-class:: classref-method
:ref:`float<class_float>` **tan**\ (\ angle_rad\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_tan>`
Devuelve la tangente del ángulo ``angle_rad`` en radianes.
::
tan(deg2rad(45)) # Devuelve 1
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_tanh:
.. rst-class:: classref-method
:ref:`float<class_float>` **tanh**\ (\ x\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_tanh>`
Devuelve la tangente hiperbólica de ``x``.
::
var a = log(2.0) # Devuelve 0.693147
tanh(a) # Devuelve 0.6
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_type_convert:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **type_convert**\ (\ variant\: :ref:`Variant<class_Variant>`, type\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_type_convert>`
Convierte un ``variant`` dado a ``type``, usando los valores de :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`. Este método es amigable con como maneja los tipos, puede convertir automáticamente entre tipos de array, convertir :ref:`String<class_String>`\ s numéricos a :ref:`int<class_int>` y convertir la gran mayoría de cosas a :ref:`String<class_String>`.
Si no se puede pasar de un tipo a otro, este método devolverá el valor por defecto de ese tipo, por ejemplo, convertir un :ref:`Rect2<class_Rect2>` a :ref:`Vector2<class_Vector2>` siempre devolverá :ref:`Vector2.ZERO<class_Vector2_constant_ZERO>`. Este método no muestra mensajes de error siempre que ``type`` sea un tipo valido.
El valor devuelto es :ref:`Variant<class_Variant>`, pero su tipo y datos serán iguales que el que se pidió.
::
type_convert("Hi!", TYPE_INT) # Devuelve 0
type_convert("123", TYPE_INT) # Devuelve 123
type_convert(123.4, TYPE_INT) # Devuelve 123
type_convert(5, TYPE_VECTOR2) # Devuelve (0, 0)
type_convert("Hi!", TYPE_NIL) # Devuelve null
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_type_string:
.. rst-class:: classref-method
:ref:`String<class_String>` **type_string**\ (\ type\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_type_string>`
Devuelve un nombre legible para el ``type`` dado, utilizando los valores de :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.
::
print(TYPE_INT) # Imprime 2
print(type_string(TYPE_INT)) # Imprime "int"
print(type_string(TYPE_STRING)) # Imprime "String"
Véase también :ref:`typeof()<class_@GlobalScope_method_typeof>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_typeof:
.. rst-class:: classref-method
:ref:`int<class_int>` **typeof**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_typeof>`
Returns the internal type of the given ``variable``, using the :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` values.
::
var json = JSON.new()
json.parse('["a", "b", "c"]')
var result = json.get_data()
if typeof(result) == TYPE_ARRAY:
print(result[0]) # Prints "a"
else:
print("Unexpected result!")
See also :ref:`type_string()<class_@GlobalScope_method_type_string>`.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_var_to_bytes:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **var_to_bytes**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_bytes>`
Cifra el valor de :ref:`Variant<class_Variant>` a un array de bytes (byte array) sin encodificar el objeto en si. La deserialización puede ser hecha con :ref:`bytes_to_var()<class_@GlobalScope_method_bytes_to_var>`.
\ **Nota:** Si necesitas serializar el objeto, véase :ref:`var_to_bytes_with_objects()<class_@GlobalScope_method_var_to_bytes_with_objects>`.
\ **Nota:** La encodificación de :ref:`Callable<class_Callable>` no esta soportada y siempre devolverá un valor vacío, sin importar los datos.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_var_to_bytes_with_objects:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **var_to_bytes_with_objects**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_bytes_with_objects>`
Codifica un valor :ref:`Variant<class_Variant>` en un array de bytes. Se permite codificar objetos (y potencialmente puede incluir código ejecutable). La deserialización puede realizarse con :ref:`bytes_to_var_with_objects()<class_@GlobalScope_method_bytes_to_var_with_objects>`.
\ **Nota:** La codificación de :ref:`Callable<class_Callable>` no es compatible y dará como resultado un valor vacío, independientemente de los datos.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_var_to_str:
.. rst-class:: classref-method
:ref:`String<class_String>` **var_to_str**\ (\ variable\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_var_to_str>`
Convierte una :ref:`Variant<class_Variant>` ``variable`` en una :ref:`String<class_String>` formateada que luego puede ser analizada utilizando :ref:`str_to_var()<class_@GlobalScope_method_str_to_var>`.
.. tabs::
.. code-tab:: gdscript
var a = { "a": 1, "b": 2 }
print(var_to_str(a))
.. code-tab:: csharp
var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
GD.Print(GD.VarToStr(a));
Imprime:
.. code:: text
{
"a": 1,
"b": 2
}
\ **Nota:** La conversión de :ref:`Signal<class_Signal>` o :ref:`Callable<class_Callable>` no es compatible y resultará en un valor vacío para estos tipos, independientemente de sus datos.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_weakref:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **weakref**\ (\ obj\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_weakref>`
Devuelve una instancia :ref:`WeakRef<class_WeakRef>` que contiene una referencia débil a ``obj``. Devuelve una instancia :ref:`WeakRef<class_WeakRef>` vacía si ``obj`` es ``null``. Imprime un error y devuelve ``null`` si ``obj`` no es derivado de :ref:`Object<class_Object>` ni ``null``.
Una referencia débil a un objeto no es suficiente para mantenerlo activo: cuando las únicas referencias restantes a un referente son débiles, la recolección de elementos no utilizados puede destruir el referente y reutilizar su memoria para otra cosa. Sin embargo, hasta que el objeto se destruya, la referencia débil puede devolverlo incluso si no existen referencias fuertes a él.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_wrap:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **wrap**\ (\ value\: :ref:`Variant<class_Variant>`, min\: :ref:`Variant<class_Variant>`, max\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_@GlobalScope_method_wrap>`
Envuelve el :ref:`Variant<class_Variant>` ``value`` entre ``min`` y ``max``. ``min`` es *inclusivo* mientras que ``max`` es *exclusivo*. Esto puede utilizarse para crear comportamientos similares a bucles o superficies infinitas.
Los tipos de :ref:`Variant<class_Variant>` compatibles son :ref:`int<class_int>` y :ref:`float<class_float>`. Si alguno de los argumentos es :ref:`float<class_float>`, esta función devuelve un :ref:`float<class_float>`, de lo contrario devuelve un :ref:`int<class_int>`.
::
var a = wrap(4, 5, 10)
# a es 9 (int)
var a = wrap(7, 5, 10)
# a es 7 (int)
var a = wrap(10.5, 5, 10)
# a es 5.5 (float)
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_wrapf:
.. rst-class:: classref-method
:ref:`float<class_float>` **wrapf**\ (\ value\: :ref:`float<class_float>`, min\: :ref:`float<class_float>`, max\: :ref:`float<class_float>`\ ) :ref:`🔗<class_@GlobalScope_method_wrapf>`
Ajusta el valor flotante ``value`` entre ``min`` y ``max``. ``min`` es *inclusivo* mientras que ``max`` es *exclusivo*. Esto puede ser usado para crear un comportamiento similar a un bucle o superficies infinitas.
::
# Bucle infinito entre 5.0 y 9.9
valor = wrapf(valor + 0.1, 5.0, 10.0)
::
# Rotación infinita (en radianes)
ángulo = wrapf(ángulo + 0.1, 0.0, TAU)
::
# Rotación infinita (en radianes)
ángulo = wrapf(ángulo + 0.1, -PI, PI)
\ **Nota:** Si ``min`` es ``0``, esto es equivalente a :ref:`fposmod()<class_@GlobalScope_method_fposmod>`, así que es preferible usar ese en su lugar. :ref:`wrapf()<class_@GlobalScope_method_wrapf>` es más flexible que usar :ref:`fposmod()<class_@GlobalScope_method_fposmod>`, ya que le da al usuario control sobre el valor mínimo.
.. rst-class:: classref-item-separator
----
.. _class_@GlobalScope_method_wrapi:
.. rst-class:: classref-method
:ref:`int<class_int>` **wrapi**\ (\ value\: :ref:`int<class_int>`, min\: :ref:`int<class_int>`, max\: :ref:`int<class_int>`\ ) :ref:`🔗<class_@GlobalScope_method_wrapi>`
Ajusta el entero ``value`` entre ``min`` y ``max``. ``min`` es *inclusivo* mientras que ``max`` es *exclusivo*. Esto puede usarse para crear un comportamiento similar a un bucle o superficies infinitas.
::
# Bucle infinito entre 5 y 9
fotograma = wrapi(fotograma + 1, 5, 10)
::
# El resultado es -2
var resultado = wrapi(-6, -5, -1)
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink