godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/es/class_viewport.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

2708 lines
167 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_Viewport:
Viewport
========
**Hereda:** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Heredado por:** :ref:`SubViewport<class_SubViewport>`, :ref:`Window<class_Window>`
Clase base abstracta para viewports. Encapsula el dibujo y la interacción con un mundo de juego.
.. rst-class:: classref-introduction-group
Descripción
----------------------
Un **Viewport** crea una vista diferente en la pantalla, o una subvista dentro de otro viewport. Los nodos 2D hijos se mostrarán en él, y los nodos 3D hijos de :ref:`Camera3D<class_Camera3D>` también se renderizarán en él.
Opcionalmente, un viewport puede tener su propio mundo 2D o 3D, de modo que no comparte lo que dibuja con otros viewports.
Los viewports también pueden optar por ser escuchas de audio, por lo que generan audio posicional dependiendo de una cámara 2D o 3D hija de él.
Además, los viewports se pueden asignar a diferentes pantallas en caso de que los dispositivos tengan múltiples pantallas.
Finalmente, los viewports también pueden comportarse como objetivos de renderizado, en cuyo caso no serán visibles a menos que se utilice la textura asociada para dibujar.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Usando Viewports <../tutorials/rendering/viewports>`
- :doc:`Viewport and canvas transforms <../tutorials/2d/2d_transforms>`
- `GUI in 3D Viewport Demo <https://godotengine.org/asset-library/asset/2807>`__
- `Demo de Viewport 3D en 2D <https://godotengine.org/asset-library/asset/2804>`__
- `2D in 3D Viewport Demo <https://godotengine.org/asset-library/asset/2803>`__
- `Demo de Captura de Pantalla <https://godotengine.org/asset-library/asset/2808>`__
- `Demo de División Dinámica de Pantalla <https://godotengine.org/asset-library/asset/2806>`__
- `Demo de Escalado de Resolución en 3D <https://godotengine.org/asset-library/asset/2805>`__
.. rst-class:: classref-reftable-group
Propiedades
----------------------
.. table::
:widths: auto
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` | :ref:`anisotropic_filtering_level<class_Viewport_property_anisotropic_filtering_level>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`audio_listener_enable_2d<class_Viewport_property_audio_listener_enable_2d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`audio_listener_enable_3d<class_Viewport_property_audio_listener_enable_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`canvas_cull_mask<class_Viewport_property_canvas_cull_mask>` | ``4294967295`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` | :ref:`canvas_item_default_texture_filter<class_Viewport_property_canvas_item_default_texture_filter>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` | :ref:`canvas_item_default_texture_repeat<class_Viewport_property_canvas_item_default_texture_repeat>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`canvas_transform<class_Viewport_property_canvas_transform>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`DebugDraw<enum_Viewport_DebugDraw>` | :ref:`debug_draw<class_Viewport_property_debug_draw>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`disable_3d<class_Viewport_property_disable_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`fsr_sharpness<class_Viewport_property_fsr_sharpness>` | ``0.2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`global_canvas_transform<class_Viewport_property_global_canvas_transform>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_disable_input<class_Viewport_property_gui_disable_input>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`gui_drag_threshold<class_Viewport_property_gui_drag_threshold>` | ``10`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_embed_subwindows<class_Viewport_property_gui_embed_subwindows>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_snap_controls_to_pixels<class_Viewport_property_gui_snap_controls_to_pixels>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`handle_input_locally<class_Viewport_property_handle_input_locally>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` | ``1.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MSAA<enum_Viewport_MSAA>` | :ref:`msaa_2d<class_Viewport_property_msaa_2d>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`MSAA<enum_Viewport_MSAA>` | :ref:`msaa_3d<class_Viewport_property_msaa_3d>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`oversampling<class_Viewport_property_oversampling>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`oversampling_override<class_Viewport_property_oversampling_override>` | ``0.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`own_world_3d<class_Viewport_property_own_world_3d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PhysicsInterpolationMode<enum_Node_PhysicsInterpolationMode>` | physics_interpolation_mode | ``1`` (overrides :ref:`Node<class_Node_property_physics_interpolation_mode>`) |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking_first_only<class_Viewport_property_physics_object_picking_first_only>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`physics_object_picking_sort<class_Viewport_property_physics_object_picking_sort>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`positional_shadow_atlas_16_bits<class_Viewport_property_positional_shadow_atlas_16_bits>` | ``true`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_0<class_Viewport_property_positional_shadow_atlas_quad_0>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_1<class_Viewport_property_positional_shadow_atlas_quad_1>` | ``2`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_2<class_Viewport_property_positional_shadow_atlas_quad_2>` | ``3`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`positional_shadow_atlas_quad_3<class_Viewport_property_positional_shadow_atlas_quad_3>` | ``4`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` | ``2048`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` | :ref:`scaling_3d_mode<class_Viewport_property_scaling_3d_mode>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>` | ``1.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` | :ref:`screen_space_aa<class_Viewport_property_screen_space_aa>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`SDFOversize<enum_Viewport_SDFOversize>` | :ref:`sdf_oversize<class_Viewport_property_sdf_oversize>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`SDFScale<enum_Viewport_SDFScale>` | :ref:`sdf_scale<class_Viewport_property_sdf_scale>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`snap_2d_transforms_to_pixel<class_Viewport_property_snap_2d_transforms_to_pixel>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`snap_2d_vertices_to_pixel<class_Viewport_property_snap_2d_vertices_to_pixel>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`texture_mipmap_bias<class_Viewport_property_texture_mipmap_bias>` | ``0.0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`transparent_bg<class_Viewport_property_transparent_bg>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_debanding<class_Viewport_property_use_debanding>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_occlusion_culling<class_Viewport_property_use_occlusion_culling>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_taa<class_Viewport_property_use_taa>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`use_xr<class_Viewport_property_use_xr>` | ``false`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`VRSMode<enum_Viewport_VRSMode>` | :ref:`vrs_mode<class_Viewport_property_vrs_mode>` | ``0`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`Texture2D<class_Texture2D>` | :ref:`vrs_texture<class_Viewport_property_vrs_texture>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` | :ref:`vrs_update_mode<class_Viewport_property_vrs_update_mode>` | ``1`` |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`world_2d<class_Viewport_property_world_2d>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
| :ref:`World3D<class_World3D>` | :ref:`world_3d<class_Viewport_property_world_3d>` | |
+-----------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Métodos
--------------
.. table::
:widths: auto
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World2D<class_World2D>` | :ref:`find_world_2d<class_Viewport_method_find_world_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`World3D<class_World3D>` | :ref:`find_world_3d<class_Viewport_method_find_world_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AudioListener2D<class_AudioListener2D>` | :ref:`get_audio_listener_2d<class_Viewport_method_get_audio_listener_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AudioListener3D<class_AudioListener3D>` | :ref:`get_audio_listener_3d<class_Viewport_method_get_audio_listener_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Camera2D<class_Camera2D>` | :ref:`get_camera_2d<class_Viewport_method_get_camera_2d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Camera3D<class_Camera3D>` | :ref:`get_camera_3d<class_Viewport_method_get_camera_3d>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_canvas_cull_mask_bit<class_Viewport_method_get_canvas_cull_mask_bit>`\ (\ layer\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`Window<class_Window>`\] | :ref:`get_embedded_subwindows<class_Viewport_method_get_embedded_subwindows>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_final_transform<class_Viewport_method_get_final_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`get_mouse_position<class_Viewport_method_get_mouse_position>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_oversampling<class_Viewport_method_get_oversampling>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` | :ref:`get_positional_shadow_atlas_quadrant_subdiv<class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv>`\ (\ quadrant\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_render_info<class_Viewport_method_get_render_info>`\ (\ type\: :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`, info\: :ref:`RenderInfo<enum_Viewport_RenderInfo>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_screen_transform<class_Viewport_method_get_screen_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform2D<class_Transform2D>` | :ref:`get_stretch_transform<class_Viewport_method_get_stretch_transform>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`ViewportTexture<class_ViewportTexture>` | :ref:`get_texture<class_Viewport_method_get_texture>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`get_viewport_rid<class_Viewport_method_get_viewport_rid>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2<class_Rect2>` | :ref:`get_visible_rect<class_Viewport_method_get_visible_rect>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_cancel_drag<class_Viewport_method_gui_cancel_drag>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`gui_get_drag_data<class_Viewport_method_gui_get_drag_data>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`gui_get_drag_description<class_Viewport_method_gui_get_drag_description>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`gui_get_focus_owner<class_Viewport_method_gui_get_focus_owner>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Control<class_Control>` | :ref:`gui_get_hovered_control<class_Viewport_method_gui_get_hovered_control>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_is_drag_successful<class_Viewport_method_gui_is_drag_successful>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`gui_is_dragging<class_Viewport_method_gui_is_dragging>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_release_focus<class_Viewport_method_gui_release_focus>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`gui_set_drag_description<class_Viewport_method_gui_set_drag_description>`\ (\ description\: :ref:`String<class_String>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_input_handled<class_Viewport_method_is_input_handled>`\ (\ ) |const| |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`notify_mouse_entered<class_Viewport_method_notify_mouse_entered>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`notify_mouse_exited<class_Viewport_method_notify_mouse_exited>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_input<class_Viewport_method_push_input>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_text_input<class_Viewport_method_push_text_input>`\ (\ text\: :ref:`String<class_String>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`push_unhandled_input<class_Viewport_method_push_unhandled_input>`\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_canvas_cull_mask_bit<class_Viewport_method_set_canvas_cull_mask_bit>`\ (\ layer\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_input_as_handled<class_Viewport_method_set_input_as_handled>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_positional_shadow_atlas_quadrant_subdiv<class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv>`\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`update_mouse_cursor_state<class_Viewport_method_update_mouse_cursor_state>`\ (\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`warp_mouse<class_Viewport_method_warp_mouse>`\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) |
+-----------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Señales
--------------
.. _class_Viewport_signal_gui_focus_changed:
.. rst-class:: classref-signal
**gui_focus_changed**\ (\ node\: :ref:`Control<class_Control>`\ ) :ref:`🔗<class_Viewport_signal_gui_focus_changed>`
Emitida cuando un nodo Control toma el foco del teclado.
\ **Nota:** Que un nodo Control pierda el foco no causa que esta señal sea emitida.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_signal_size_changed:
.. rst-class:: classref-signal
**size_changed**\ (\ ) :ref:`🔗<class_Viewport_signal_size_changed>`
Emitida cuando se cambia el tamaño del viewport, ya sea cambiando el tamaño de la ventana o por algún otro medio.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumeraciones
--------------------------
.. _enum_Viewport_PositionalShadowAtlasQuadrantSubdiv:
.. rst-class:: classref-enumeration
enum **PositionalShadowAtlasQuadrantSubdiv**: :ref:`🔗<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_DISABLED** = ``0``
Este cuadrante no será utilizado.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1** = ``1``
Este cuadrante sólo será usado por un mapa de sombras.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_4:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_4** = ``2``
Este cuadrante se dividirá en 4 y será usado por hasta 4 mapas de sombras.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_16:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_16** = ``3``
Este cuadrante se dividirá en 16 partes y será utilizado por hasta 16 mapas de sombras.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_64:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_64** = ``4``
Este cuadrante se dividirá en 64 partes y será utilizado por hasta 64 mapas de sombras.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_256:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_256** = ``5``
Este cuadrante se dividirá en 256 partes y será utilizado por hasta 256 mapas de sombras. A menos que el valor de :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` sea muy alto, las sombras en este cuadrante tendrán muy baja resolución.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1024:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1024** = ``6``
Este cuadrante se dividirá en 1024 partes y será utilizado por hasta 1024 mapas de sombras. A menos que el valor de :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` sea muy alto, las sombras en este cuadrante tendrán muy baja resolución.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_MAX** = ``7``
Representa el tamaño del enum :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_Scaling3DMode:
.. rst-class:: classref-enumeration
enum **Scaling3DMode**: :ref:`🔗<enum_Viewport_Scaling3DMode>`
.. _class_Viewport_constant_SCALING_3D_MODE_BILINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_BILINEAR** = ``0``
Usa escalado bilineal para el búfer 3D del viewport. La cantidad de escalado se puede establecer usando :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Valores menores que ``1.0`` resultarán en submuestreo mientras que valores mayores a ``1.0`` resultarán en sobremuestreo. Un valor de ``1.0`` deshabilita el escalado.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR** = ``1``
Usa el reescalado AMD FidelityFX Super Resolution 1.0 para el búfer 3D del viewport. La cantidad de escalado se puede establecer usando :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Valores menores a ``1.0`` resultarán en que el viewport sea reescalado usando FSR. Valores mayores a ``1.0`` no son soportados y en su lugar se usará un submuestreo bilineal. Un valor de ``1.0`` deshabilita el escalado.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR2:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR2** = ``2``
Utiliza el upscaling AMD FidelityFX Super Resolution 2.2 para el búfer 3D del viewport. La cantidad de escalado se puede establecer utilizando :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Los valores menores que ``1.0`` harán que el viewport se escale utilizando FSR2. Los valores mayores que ``1.0`` no son compatibles y, en su lugar, se utilizará el submuestreo bilineal. Un valor de ``1.0`` utilizará FSR2 a resolución nativa como una solución TAA.
.. _class_Viewport_constant_SCALING_3D_MODE_METALFX_SPATIAL:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_METALFX_SPATIAL** = ``3``
Usa el `reescalador espacial MetalFX <https://developer.apple.com/documentation/metalfx/mtlfxspatialscaler#overview>`__ para el búfer 3D del viewport.
La cantidad de escalado se puede establecer usando :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`.
Valores menores a ``1.0`` resultarán en que el viewport sea reescalado usando MetalFX. Valores mayores a ``1.0`` no son soportados y en su lugar se usará submuestreo bilineal. Un valor de ``1.0`` deshabilita el escalado.
Más información: `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Nota:** Sólo soportado cuando el controlador de renderizado Metal está en uso, lo que limita este modo de escalado a macOS e iOS.
.. _class_Viewport_constant_SCALING_3D_MODE_METALFX_TEMPORAL:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_METALFX_TEMPORAL** = ``4``
Utiliza el `reescalador temporal MetalFX <https://developer.apple.com/documentation/metalfx/mtlfxtemporalscaler#overview>`__ para el búfer 3D del viewport.
La cantidad de escalado se puede establecer utilizando :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Para determinar la escala de entrada mínima, utiliza el método :ref:`RenderingDevice.limit_get()<class_RenderingDevice_method_limit_get>` con :ref:`RenderingDevice.LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE<class_RenderingDevice_constant_LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE>`.
Los valores inferiores a ``1.0`` harán que el viewport se escale utilizando MetalFX. Los valores mayores que ``1.0`` no son compatibles y en su lugar se utilizará el submuestreo bilineal. Un valor de ``1.0`` utilizará MetalFX en la resolución nativa como una solución TAA.
Más información: `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Nota:** Sólo se admite cuando se utiliza el controlador de renderizado Metal, lo que limita este modo de escalado a macOS e iOS.
.. _class_Viewport_constant_SCALING_3D_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_MAX** = ``5``
Representa el tamaño del enum :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_MSAA:
.. rst-class:: classref-enumeration
enum **MSAA**: :ref:`🔗<enum_Viewport_MSAA>`
.. _class_Viewport_constant_MSAA_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_DISABLED** = ``0``
Modo de antialiasing multisample desactivado. Este es el valor predeterminado, y también la configuración más rápida.
.. _class_Viewport_constant_MSAA_2X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_2X** = ``1``
Usar antialiasing multisample 2×. Esto tiene un coste de rendimiento moderado. Ayuda a reducir el aliasing notablemente, pero el MSAA 4× sigue viéndose sustancialmente mejor.
.. _class_Viewport_constant_MSAA_4X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_4X** = ``2``
Usar antialiasing multisample 4×. Esto tiene un coste de rendimiento significativo, y generalmente es un buen compromiso entre rendimiento y calidad.
.. _class_Viewport_constant_MSAA_8X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_8X** = ``3``
Usar antialiasing multisample 8×. Esto tiene un coste de rendimiento muy alto. La diferencia entre MSAA 4× y 8× puede no ser siempre visible en condiciones de juego reales. Probablemente no sea compatible con hardware de gama baja o antiguo.
.. _class_Viewport_constant_MSAA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_MAX** = ``4``
Representa el tamaño del enum :ref:`MSAA<enum_Viewport_MSAA>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_AnisotropicFiltering:
.. rst-class:: classref-enumeration
enum **AnisotropicFiltering**: :ref:`🔗<enum_Viewport_AnisotropicFiltering>`
.. _class_Viewport_constant_ANISOTROPY_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_DISABLED** = ``0``
El filtrado anisotrópico está desactivado.
.. _class_Viewport_constant_ANISOTROPY_2X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_2X** = ``1``
Usar filtrado anisotrópico 2×.
.. _class_Viewport_constant_ANISOTROPY_4X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_4X** = ``2``
Usar filtrado anisotrópico 4×. Este es el valor predeterminado.
.. _class_Viewport_constant_ANISOTROPY_8X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_8X** = ``3``
Usar filtrado anisotrópico 8×.
.. _class_Viewport_constant_ANISOTROPY_16X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_16X** = ``4``
Usar filtrado anisotrópico 16×.
.. _class_Viewport_constant_ANISOTROPY_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_MAX** = ``5``
Representa el tamaño del enum :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_ScreenSpaceAA:
.. rst-class:: classref-enumeration
enum **ScreenSpaceAA**: :ref:`🔗<enum_Viewport_ScreenSpaceAA>`
.. _class_Viewport_constant_SCREEN_SPACE_AA_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_DISABLED** = ``0``
No realizar ningún antialiasing en el post-procesamiento de pantalla completa.
.. _class_Viewport_constant_SCREEN_SPACE_AA_FXAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_FXAA** = ``1``
Usar antialiasing aproximado rápido. FXAA es un método popular de antialiasing en el espacio de la pantalla, que es rápido pero hará que la imagen se vea borrosa, especialmente en resoluciones más bajas. Aún puede funcionar relativamente bien en resoluciones grandes como 1440p y 4K.
.. _class_Viewport_constant_SCREEN_SPACE_AA_SMAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_SMAA** = ``2``
Usar antialiasing morfológico de subpíxeles. SMAA puede producir resultados más claros que FXAA, pero con un coste de rendimiento ligeramente superior.
.. _class_Viewport_constant_SCREEN_SPACE_AA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_MAX** = ``3``
Representa el tamaño del enum :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_RenderInfo:
.. rst-class:: classref-enumeration
enum **RenderInfo**: :ref:`🔗<enum_Viewport_RenderInfo>`
.. _class_Viewport_constant_RENDER_INFO_OBJECTS_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_OBJECTS_IN_FRAME** = ``0``
Cantidad de objetos en el fotograma.
.. _class_Viewport_constant_RENDER_INFO_PRIMITIVES_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_PRIMITIVES_IN_FRAME** = ``1``
Cantidad de vértices en el fotograma.
.. _class_Viewport_constant_RENDER_INFO_DRAW_CALLS_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_DRAW_CALLS_IN_FRAME** = ``2``
Cantidad de llamadas de dibujo en el fotograma.
.. _class_Viewport_constant_RENDER_INFO_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_MAX** = ``3``
Representa el tamaño del enum :ref:`RenderInfo<enum_Viewport_RenderInfo>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_RenderInfoType:
.. rst-class:: classref-enumeration
enum **RenderInfoType**: :ref:`🔗<enum_Viewport_RenderInfoType>`
.. _class_Viewport_constant_RENDER_INFO_TYPE_VISIBLE:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_VISIBLE** = ``0``
Pase de renderizado visible (excluidas las sombras).
.. _class_Viewport_constant_RENDER_INFO_TYPE_SHADOW:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_SHADOW** = ``1``
Paso de renderizado de sombras. Los objetos se renderizarán varias veces dependiendo de la cantidad de luces con sombras y el número de divisiones de sombras direccionales.
.. _class_Viewport_constant_RENDER_INFO_TYPE_CANVAS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_CANVAS** = ``2``
Renderizado de elementos del canvas. Esto incluye todo el renderizado 2D.
.. _class_Viewport_constant_RENDER_INFO_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_MAX** = ``3``
Representa el tamaño del enum :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DebugDraw:
.. rst-class:: classref-enumeration
enum **DebugDraw**: :ref:`🔗<enum_Viewport_DebugDraw>`
.. _class_Viewport_constant_DEBUG_DRAW_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DISABLED** = ``0``
Los objetos se muestran normalmente.
.. _class_Viewport_constant_DEBUG_DRAW_UNSHADED:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_UNSHADED** = ``1``
Los objetos se muestran sin información de la luz.
.. _class_Viewport_constant_DEBUG_DRAW_LIGHTING:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_LIGHTING** = ``2``
Los objetos se muestran sin texturas y solo con información de iluminación.
\ **Nota:** Al usar este modo de dibujo de depuración, los shaders personalizados se ignoran, ya que todos los materiales de la escena utilizan temporalmente un material de depuración. Esto significa que el resultado de las funciones de sombreado personalizadas (como el desplazamiento de vértices) ya no será visible cuando se utilice este modo de dibujo de depuración.
.. _class_Viewport_constant_DEBUG_DRAW_OVERDRAW:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OVERDRAW** = ``3``
Los objetos se muestran semitransparentes con mezcla aditiva para que puedas ver dónde se dibujan unos encima de otros. Un sobredibujado más alto significa que estás malgastando rendimiento dibujando píxeles que se ocultan detrás de otros.
\ **Nota:** Al usar este modo de dibujo de depuración, los shaders personalizados se ignoran, ya que todos los materiales de la escena utilizan temporalmente un material de depuración. Esto significa que el resultado de las funciones de sombreado personalizadas (como el desplazamiento de vértices) ya no será visible cuando se utilice este modo de dibujo de depuración.
.. _class_Viewport_constant_DEBUG_DRAW_WIREFRAME:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_WIREFRAME** = ``4``
Los objetos se muestran como modelos de alambre (wireframe).
\ **Nota:** Se debe llamar a :ref:`RenderingServer.set_debug_generate_wireframes()<class_RenderingServer_method_set_debug_generate_wireframes>` antes de cargar cualquier malla para que los wireframes sean visibles cuando se utiliza el renderizador de Compatibility.
.. _class_Viewport_constant_DEBUG_DRAW_NORMAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_NORMAL_BUFFER** = ``5``
Los objetos se muestran sin información de iluminación y sus texturas son reemplazadas por el mapeo de normales.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_ALBEDO:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_ALBEDO** = ``6``
Los objetos se muestran solo con el valor albedo de los :ref:`VoxelGI<class_VoxelGI>`. Requiere al menos un nodo :ref:`VoxelGI<class_VoxelGI>` visible que haya sido procesado para tener un efecto visible.
\ **Nota:** Solo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_LIGHTING:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_LIGHTING** = ``7``
Los objetos se muestran solo con el valor de iluminación de los :ref:`VoxelGI<class_VoxelGI>`. Requiere al menos un nodo :ref:`VoxelGI<class_VoxelGI>` visible que haya sido procesado para tener un efecto visible.
\ **Nota:** Solo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_VOXEL_GI_EMISSION:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_VOXEL_GI_EMISSION** = ``8``
Los objetos se muestran solo con el color de emisión de los :ref:`VoxelGI<class_VoxelGI>`. Requiere al menos un nodo :ref:`VoxelGI<class_VoxelGI>` visible que haya sido procesado para tener un efecto visible.
\ **Nota:** Solo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SHADOW_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SHADOW_ATLAS** = ``9``
Dibuja el atlas de sombras que almacena las sombras de las :ref:`OmniLight3D<class_OmniLight3D>` y :ref:`SpotLight3D<class_SpotLight3D>` en el cuadrante superior izquierdo del **Viewport**.
.. _class_Viewport_constant_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS** = ``10``
Dibuja el atlas de sombras que almacena las sombras de los :ref:`DirectionalLight3D<class_DirectionalLight3D>` en el cuadrante superior izquierdo del **Viewport**.
.. _class_Viewport_constant_DEBUG_DRAW_SCENE_LUMINANCE:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SCENE_LUMINANCE** = ``11``
Dibuja el búfer de luminancia de la escena (si está disponible) en el cuadrante superior izquierdo del **Viewport**.
\ **Nota:** Solo es compatible cuando se utilizan los métodos de renderizado Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_SSAO:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSAO** = ``12``
Dibuja la textura de oclusión ambiental del espacio de la pantalla en lugar de la escena, para que pueda ver claramente cómo está afectando a los objetos. Para que este modo de visualización funcione, debe tener :ref:`Environment.ssao_enabled<class_Environment_property_ssao_enabled>` establecido en su :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Nota:** Sólo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SSIL:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSIL** = ``13``
Dibuja la textura de iluminación indirecta del espacio de la pantalla en lugar de la escena, para que pueda ver claramente cómo está afectando a los objetos. Para que este modo de visualización funcione, debe tener :ref:`Environment.ssil_enabled<class_Environment_property_ssil_enabled>` establecido en su :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Nota:** Sólo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_PSSM_SPLITS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_PSSM_SPLITS** = ``14``
Colorea cada división PSSM para los :ref:`DirectionalLight3D<class_DirectionalLight3D>` en la escena con un color diferente para que puedas ver dónde están las divisiones. En orden (desde el más cercano al más lejano de la cámara), se colorean de rojo, verde, azul y amarillo.
\ **Nota:** Cuando se utiliza este modo de dibujo de depuración, se ignoran los shaders personalizados, ya que todos los materiales de la escena utilizan temporalmente un material de depuración. Esto significa que el resultado de las funciones de shader personalizadas (como el desplazamiento de vértices) ya no será visible cuando se utilice este modo de dibujo de depuración.
\ **Nota:** Solo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_DECAL_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DECAL_ATLAS** = ``15``
Dibuja el atlas de calcomanías utilizado por los :ref:`Decal<class_Decal>`\ s y las texturas del proyector de luz en el cuadrante superior izquierdo del **Viewport**.
\ **Nota:** Sólo se admite cuando se utilizan los métodos de renderizado Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI** = ``16``
Dibuja las cascadas utilizadas para renderizar la iluminación global del campo de distancia firmado (SDFGI).
No hace nada si el :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` del entorno actual es ``false``.
\ **Nota:** Sólo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI_PROBES** = ``17``
Draws the probes used for signed distance field global illumination (SDFGI).
When in the editor, left-clicking a probe will display additional bright dots that show its occlusion information. A white dot means the light is not occluded at all at the dot's position, while a red dot means the light is fully occluded. Intermediate values are possible.
Does nothing if the current environment's :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` is ``false``.
\ **Note:** Only supported when using the Forward+ rendering method.
.. _class_Viewport_constant_DEBUG_DRAW_GI_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_GI_BUFFER** = ``18``
Dibuja el búfer utilizado para la iluminación global de :ref:`VoxelGI<class_VoxelGI>` o SDFGI. Requiere que :ref:`VoxelGI<class_VoxelGI>` (al menos un nodo VoxelGI procesado visible) o SDFGI (:ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>`) estén habilitados para tener un efecto visible.
\ **Nota:** Sólo se admite cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_DISABLE_LOD:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DISABLE_LOD** = ``19``
Dibuja todos los objetos con su mayor número de polígonos, independientemente de su distancia a la cámara. No se aplica ningún nivel de detalle bajo (LOD).
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_OMNI_LIGHTS** = ``20``
Dibuja el clúster utilizado por los nodos :ref:`OmniLight3D<class_OmniLight3D>` para optimizar el renderizado de la luz.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_SPOT_LIGHTS** = ``21``
Dibuja el clúster utilizado por los nodos :ref:`SpotLight3D<class_SpotLight3D>` para optimizar el renderizado de la luz.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_DECALS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_DECALS** = ``22``
Dibuja el clúster utilizado por los nodos :ref:`Decal<class_Decal>` para optimizar el renderizado de calcomanías.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_REFLECTION_PROBES** = ``23``
Dibuja el clúster utilizado por los nodos :ref:`ReflectionProbe<class_ReflectionProbe>` para optimizar las sondas de reflexión.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_OCCLUDERS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OCCLUDERS** = ``24``
Dibuja el búfer utilizado para la oclusión.
\ **Nota:** Solo es compatible cuando se utilizan los métodos de renderizado Forward+ o Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_MOTION_VECTORS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_MOTION_VECTORS** = ``25``
Dibuja líneas vectoriales sobre el viewport para indicar el movimiento de los píxeles entre fotogramas.
\ **Nota:** Solo es compatible cuando se utiliza el método de renderizado Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_INTERNAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_INTERNAL_BUFFER** = ``26``
Dibuja el búfer de resolución interna de la escena en un espacio de color lineal antes de que se aplique el mapeo de tonos o el post-procesado.
\ **Nota:** Solo es compatible cuando se utilizan los métodos de renderizado Forward+ o Mobile.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DefaultCanvasItemTextureFilter:
.. rst-class:: classref-enumeration
enum **DefaultCanvasItemTextureFilter**: :ref:`🔗<enum_Viewport_DefaultCanvasItemTextureFilter>`
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST** = ``0``
The texture filter reads from the nearest pixel only. This makes the texture look pixelated from up close, and grainy from a distance (due to mipmaps not being sampled).
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR** = ``1``
The texture filter blends between the nearest 4 pixels. This makes the texture look smooth from up close, and grainy from a distance (due to mipmaps not being sampled).
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS** = ``2``
The texture filter blends between the nearest 4 pixels and between the nearest 2 mipmaps (or uses the nearest mipmap if :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` is ``true``). This makes the texture look smooth from up close, and smooth from a distance.
Use this for non-pixel art textures that may be viewed at a low scale (e.g. due to :ref:`Camera2D<class_Camera2D>` zoom or sprite scaling), as mipmaps are important to smooth out pixels that are smaller than on-screen pixels.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS** = ``3``
The texture filter reads from the nearest pixel and blends between the nearest 2 mipmaps (or uses the nearest mipmap if :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` is ``true``). This makes the texture look pixelated from up close, and smooth from a distance.
Use this for non-pixel art textures that may be viewed at a low scale (e.g. due to :ref:`Camera2D<class_Camera2D>` zoom or sprite scaling), as mipmaps are important to smooth out pixels that are smaller than on-screen pixels.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **DEFAULT_CANVAS_ITEM_TEXTURE_FILTER_MAX** = ``4``
Representa el tamaño del enum :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_DefaultCanvasItemTextureRepeat:
.. rst-class:: classref-enumeration
enum **DefaultCanvasItemTextureRepeat**: :ref:`🔗<enum_Viewport_DefaultCanvasItemTextureRepeat>`
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_DISABLED** = ``0``
Desactiva la repetición de texturas. En su lugar, al leer UVs fuera del rango 0-1, el valor se sujetará al borde de la textura, resultando en un aspecto estirado en los bordes de la textura.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_ENABLED:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_ENABLED** = ``1``
Enables the texture to repeat when UV coordinates are outside the 0-1 range. If using one of the linear filtering modes, this can result in artifacts at the edges of a texture when the sampler filters across the edges of the texture.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MIRROR:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MIRROR** = ``2``
Invierte la textura al repetirla para que el borde se alinee en lugar de cambiar bruscamente.
.. _class_Viewport_constant_DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **DEFAULT_CANVAS_ITEM_TEXTURE_REPEAT_MAX** = ``3``
Representa el tamaño del enum :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_SDFOversize:
.. rst-class:: classref-enumeration
enum **SDFOversize**: :ref:`🔗<enum_Viewport_SDFOversize>`
.. _class_Viewport_constant_SDF_OVERSIZE_100_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_100_PERCENT** = ``0``
El campo de distancia con signo solo cubre el propio rectángulo del viewport.
.. _class_Viewport_constant_SDF_OVERSIZE_120_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_120_PERCENT** = ``1``
El campo de distancia con signo se expande para cubrir el 20% del tamaño del viewport alrededor de los bordes.
.. _class_Viewport_constant_SDF_OVERSIZE_150_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_150_PERCENT** = ``2``
El campo de distancia con signo se expande para cubrir el 50% del tamaño del viewport alrededor de los bordes.
.. _class_Viewport_constant_SDF_OVERSIZE_200_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_200_PERCENT** = ``3``
El campo de distancia con signo se expande para cubrir el 100% (el doble) del tamaño del viewport alrededor de los bordes.
.. _class_Viewport_constant_SDF_OVERSIZE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_MAX** = ``4``
Representa el tamaño del enum :ref:`SDFOversize<enum_Viewport_SDFOversize>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_SDFScale:
.. rst-class:: classref-enumeration
enum **SDFScale**: :ref:`🔗<enum_Viewport_SDFScale>`
.. _class_Viewport_constant_SDF_SCALE_100_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_100_PERCENT** = ``0``
El campo de distancia con signo se renderiza a resolución completa.
.. _class_Viewport_constant_SDF_SCALE_50_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_50_PERCENT** = ``1``
El campo de distancia con signo se renderiza a la mitad de la resolución de este viewport.
.. _class_Viewport_constant_SDF_SCALE_25_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_25_PERCENT** = ``2``
El campo de distancia con signo se renderiza a un cuarto de la resolución de este viewport.
.. _class_Viewport_constant_SDF_SCALE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_MAX** = ``3``
Representa el tamaño del enum :ref:`SDFScale<enum_Viewport_SDFScale>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_VRSMode:
.. rst-class:: classref-enumeration
enum **VRSMode**: :ref:`🔗<enum_Viewport_VRSMode>`
.. _class_Viewport_constant_VRS_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_DISABLED** = ``0``
El sombreado de tasa variable está desactivado.
.. _class_Viewport_constant_VRS_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_TEXTURE** = ``1``
El sombreado de tasa variable utiliza una textura. Nota: para uso estereoscópico, utiliza un atlas de texturas con una textura para cada vista.
.. _class_Viewport_constant_VRS_XR:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_XR** = ``2``
La textura del sombreado de tasa variable es suministrada por la :ref:`XRInterface<class_XRInterface>` principal.
.. _class_Viewport_constant_VRS_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_MAX** = ``3``
Representa el tamaño del enum :ref:`VRSMode<enum_Viewport_VRSMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Viewport_VRSUpdateMode:
.. rst-class:: classref-enumeration
enum **VRSUpdateMode**: :ref:`🔗<enum_Viewport_VRSUpdateMode>`
.. _class_Viewport_constant_VRS_UPDATE_DISABLED:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_DISABLED** = ``0``
La textura de entrada para el sombreado de velocidad variable no se procesará.
.. _class_Viewport_constant_VRS_UPDATE_ONCE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ONCE** = ``1``
La textura de entrada para el sombreado de velocidad variable se procesará una vez.
.. _class_Viewport_constant_VRS_UPDATE_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ALWAYS** = ``2``
La textura de entrada para el sombreado de velocidad variable se procesará en cada frame.
.. _class_Viewport_constant_VRS_UPDATE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_MAX** = ``3``
Representa el tamaño del enum :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Propiedades
--------------------------------------------------------
.. _class_Viewport_property_anisotropic_filtering_level:
.. rst-class:: classref-property
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **anisotropic_filtering_level** = ``2`` :ref:`🔗<class_Viewport_property_anisotropic_filtering_level>`
.. rst-class:: classref-property-setget
- |void| **set_anisotropic_filtering_level**\ (\ value\: :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>`\ )
- :ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **get_anisotropic_filtering_level**\ (\ )
Sets the maximum number of samples to take when using anisotropic filtering on textures (as a power of two). A higher sample count will result in sharper textures at oblique angles, but is more expensive to compute. A value of ``0`` forcibly disables anisotropic filtering, even on materials where it is enabled.
The anisotropic filtering level also affects decals and light projectors if they are configured to use anisotropic filtering. See :ref:`ProjectSettings.rendering/textures/decals/filter<class_ProjectSettings_property_rendering/textures/decals/filter>` and :ref:`ProjectSettings.rendering/textures/light_projectors/filter<class_ProjectSettings_property_rendering/textures/light_projectors/filter>`.
\ **Note:** In 3D, for this setting to have an effect, set :ref:`BaseMaterial3D.texture_filter<class_BaseMaterial3D_property_texture_filter>` to :ref:`BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` or :ref:`BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` on materials.
\ **Note:** In 2D, for this setting to have an effect, set :ref:`CanvasItem.texture_filter<class_CanvasItem_property_texture_filter>` to :ref:`CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` or :ref:`CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` on the :ref:`CanvasItem<class_CanvasItem>` node displaying the texture (or in :ref:`CanvasTexture<class_CanvasTexture>`). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_audio_listener_enable_2d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **audio_listener_enable_2d** = ``false`` :ref:`🔗<class_Viewport_property_audio_listener_enable_2d>`
.. rst-class:: classref-property-setget
- |void| **set_as_audio_listener_2d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_audio_listener_2d**\ (\ )
Si es ``true``, el viewport procesará streams de audio en 2D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_audio_listener_enable_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **audio_listener_enable_3d** = ``false`` :ref:`🔗<class_Viewport_property_audio_listener_enable_3d>`
.. rst-class:: classref-property-setget
- |void| **set_as_audio_listener_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_audio_listener_3d**\ (\ )
Si es ``true``, el viewport procesará streams de audio en 3D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_cull_mask:
.. rst-class:: classref-property
:ref:`int<class_int>` **canvas_cull_mask** = ``4294967295`` :ref:`🔗<class_Viewport_property_canvas_cull_mask>`
.. rst-class:: classref-property-setget
- |void| **set_canvas_cull_mask**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_canvas_cull_mask**\ (\ )
The rendering layers in which this **Viewport** renders :ref:`CanvasItem<class_CanvasItem>` nodes.
\ **Note:** A :ref:`CanvasItem<class_CanvasItem>` does not inherit its parents' visibility layers. See :ref:`CanvasItem.visibility_layer<class_CanvasItem_property_visibility_layer>`'s description for details.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_item_default_texture_filter:
.. rst-class:: classref-property
:ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **canvas_item_default_texture_filter** = ``1`` :ref:`🔗<class_Viewport_property_canvas_item_default_texture_filter>`
.. rst-class:: classref-property-setget
- |void| **set_default_canvas_item_texture_filter**\ (\ value\: :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>`\ )
- :ref:`DefaultCanvasItemTextureFilter<enum_Viewport_DefaultCanvasItemTextureFilter>` **get_default_canvas_item_texture_filter**\ (\ )
The default filter mode used by :ref:`CanvasItem<class_CanvasItem>` nodes in this viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_item_default_texture_repeat:
.. rst-class:: classref-property
:ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **canvas_item_default_texture_repeat** = ``0`` :ref:`🔗<class_Viewport_property_canvas_item_default_texture_repeat>`
.. rst-class:: classref-property-setget
- |void| **set_default_canvas_item_texture_repeat**\ (\ value\: :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>`\ )
- :ref:`DefaultCanvasItemTextureRepeat<enum_Viewport_DefaultCanvasItemTextureRepeat>` **get_default_canvas_item_texture_repeat**\ (\ )
The default repeat mode used by :ref:`CanvasItem<class_CanvasItem>` nodes in this viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_canvas_transform:
.. rst-class:: classref-property
:ref:`Transform2D<class_Transform2D>` **canvas_transform** :ref:`🔗<class_Viewport_property_canvas_transform>`
.. rst-class:: classref-property-setget
- |void| **set_canvas_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
- :ref:`Transform2D<class_Transform2D>` **get_canvas_transform**\ (\ )
La transformación del canvas del viewport, útil para cambiar las posiciones en pantalla de todos los :ref:`CanvasItem<class_CanvasItem>`\ s hijos. Esto es relativo a la transformación global del canvas del viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_debug_draw:
.. rst-class:: classref-property
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **debug_draw** = ``0`` :ref:`🔗<class_Viewport_property_debug_draw>`
.. rst-class:: classref-property-setget
- |void| **set_debug_draw**\ (\ value\: :ref:`DebugDraw<enum_Viewport_DebugDraw>`\ )
- :ref:`DebugDraw<enum_Viewport_DebugDraw>` **get_debug_draw**\ (\ )
El modo de superposición para la prueba renderizó la geometría con fines de depuración.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_disable_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **disable_3d** = ``false`` :ref:`🔗<class_Viewport_property_disable_3d>`
.. rst-class:: classref-property-setget
- |void| **set_disable_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_3d_disabled**\ (\ )
Desactiva el renderizado 3D (pero mantiene el renderizado 2D).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_fsr_sharpness:
.. rst-class:: classref-property
:ref:`float<class_float>` **fsr_sharpness** = ``0.2`` :ref:`🔗<class_Viewport_property_fsr_sharpness>`
.. rst-class:: classref-property-setget
- |void| **set_fsr_sharpness**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_fsr_sharpness**\ (\ )
Determina la nitidez de la imagen sobreescalada al usar el modo de sobreescalado FSR. La nitidez se reduce a la mitad con cada número entero. Los valores van de 0.0 (máxima nitidez) a 2.0. Los valores por encima de 2.0 no supondrán una diferencia visible.
Para controlar esta propiedad en el viewport raíz, establece la configuración de proyecto :ref:`ProjectSettings.rendering/scaling_3d/fsr_sharpness<class_ProjectSettings_property_rendering/scaling_3d/fsr_sharpness>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_global_canvas_transform:
.. rst-class:: classref-property
:ref:`Transform2D<class_Transform2D>` **global_canvas_transform** :ref:`🔗<class_Viewport_property_global_canvas_transform>`
.. rst-class:: classref-property-setget
- |void| **set_global_canvas_transform**\ (\ value\: :ref:`Transform2D<class_Transform2D>`\ )
- :ref:`Transform2D<class_Transform2D>` **get_global_canvas_transform**\ (\ )
La transformación del canvas global del viewport. La transformación del canvas es relativa a esto.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_disable_input:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_disable_input** = ``false`` :ref:`🔗<class_Viewport_property_gui_disable_input>`
.. rst-class:: classref-property-setget
- |void| **set_disable_input**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_input_disabled**\ (\ )
Si es ``true``, el viewport no recibirá eventos de entrada.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_drag_threshold:
.. rst-class:: classref-property
:ref:`int<class_int>` **gui_drag_threshold** = ``10`` :ref:`🔗<class_Viewport_property_gui_drag_threshold>`
.. rst-class:: classref-property-setget
- |void| **set_drag_threshold**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_drag_threshold**\ (\ )
The minimum distance the mouse cursor must move while pressed before a drag operation begins.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_embed_subwindows:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_embed_subwindows** = ``false`` :ref:`🔗<class_Viewport_property_gui_embed_subwindows>`
.. rst-class:: classref-property-setget
- |void| **set_embedding_subwindows**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_embedding_subwindows**\ (\ )
Si es ``true``, las sub-ventanas (ventanas emergentes y diálogos) se incrustarán dentro de la ventana de la aplicación como nodos de tipo control. Si es ``false``, aparecerán como ventanas separadas manejadas por el sistema operativo.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_gui_snap_controls_to_pixels:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **gui_snap_controls_to_pixels** = ``true`` :ref:`🔗<class_Viewport_property_gui_snap_controls_to_pixels>`
.. rst-class:: classref-property-setget
- |void| **set_snap_controls_to_pixels**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_controls_to_pixels_enabled**\ (\ )
Si es ``true``, los controles GUI en el viewport colocarán los píxeles perfectamente.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_handle_input_locally:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **handle_input_locally** = ``true`` :ref:`🔗<class_Viewport_property_handle_input_locally>`
.. rst-class:: classref-property-setget
- |void| **set_handle_input_locally**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_handling_input_locally**\ (\ )
Si es ``true``, este viewport marcará los eventos de entrada entrantes como manejados por sí mismo. Si es ``false``, esto lo hará en su lugar el primer viewport padre que esté configurado para manejar la entrada localmente.
Un :ref:`SubViewportContainer<class_SubViewportContainer>` establecerá automáticamente esta propiedad a ``false`` para el **Viewport** contenido dentro de él.
Véase también :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` e :ref:`is_input_handled()<class_Viewport_method_is_input_handled>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_mesh_lod_threshold:
.. rst-class:: classref-property
:ref:`float<class_float>` **mesh_lod_threshold** = ``1.0`` :ref:`🔗<class_Viewport_property_mesh_lod_threshold>`
.. rst-class:: classref-property-setget
- |void| **set_mesh_lod_threshold**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_mesh_lod_threshold**\ (\ )
El sesgo LOD automático que se utilizará para las mallas renderizadas dentro del **Viewport** (esto es análogo a :ref:`ReflectionProbe.mesh_lod_threshold<class_ReflectionProbe_property_mesh_lod_threshold>`). Los valores más altos utilizarán versiones menos detalladas de las mallas que tienen variaciones LOD generadas. Si se establece en ``0.0``, el LOD automático se desactiva. Aumente :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` para mejorar el rendimiento a costa del detalle de la geometría.
Para controlar esta propiedad en el viewport raíz, establezca el ajuste del proyecto :ref:`ProjectSettings.rendering/mesh_lod/lod_change/threshold_pixels<class_ProjectSettings_property_rendering/mesh_lod/lod_change/threshold_pixels>`.
\ **Nota:** :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` no afecta a los rangos de visibilidad de :ref:`GeometryInstance3D<class_GeometryInstance3D>` (también conocidos como LOD "manual" o LOD jerárquico).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_msaa_2d:
.. rst-class:: classref-property
:ref:`MSAA<enum_Viewport_MSAA>` **msaa_2d** = ``0`` :ref:`🔗<class_Viewport_property_msaa_2d>`
.. rst-class:: classref-property-setget
- |void| **set_msaa_2d**\ (\ value\: :ref:`MSAA<enum_Viewport_MSAA>`\ )
- :ref:`MSAA<enum_Viewport_MSAA>` **get_msaa_2d**\ (\ )
El modo de antialiasing multisample para el renderizado 2D/Canvas. Un número mayor resulta en bordes más suaves a costa de un rendimiento significativamente peor. Un valor de :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` o :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` es lo mejor a menos que se trate de sistemas de muy alta gama. Esto no tiene ningún efecto sobre el aliasing inducido por el sombreador o el aliasing de la textura.
Véase también :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_2d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_2d>` y :ref:`RenderingServer.viewport_set_msaa_2d()<class_RenderingServer_method_viewport_set_msaa_2d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_msaa_3d:
.. rst-class:: classref-property
:ref:`MSAA<enum_Viewport_MSAA>` **msaa_3d** = ``0`` :ref:`🔗<class_Viewport_property_msaa_3d>`
.. rst-class:: classref-property-setget
- |void| **set_msaa_3d**\ (\ value\: :ref:`MSAA<enum_Viewport_MSAA>`\ )
- :ref:`MSAA<enum_Viewport_MSAA>` **get_msaa_3d**\ (\ )
El modo de antialiasing multisample para el renderizado 3D. Un número mayor resulta en bordes más suaves a costa de un rendimiento significativamente peor. Un valor de :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` o :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` es mejor a menos que se trate de sistemas de muy alta gama. Véase también el escalado bilineal 3D :ref:`scaling_3d_mode<class_Viewport_property_scaling_3d_mode>` para el supersampling, que proporciona mayor calidad pero es mucho más costoso. Esto no tiene ningún efecto sobre el aliasing inducido por el sombreador o el aliasing de la textura.
Véase también :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` y :ref:`RenderingServer.viewport_set_msaa_3d()<class_RenderingServer_method_viewport_set_msaa_3d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_oversampling:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **oversampling** = ``true`` :ref:`🔗<class_Viewport_property_oversampling>`
.. rst-class:: classref-property-setget
- |void| **set_use_oversampling**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_oversampling**\ (\ )
Si es ``true`` y se cumple una de las siguientes condiciones: se establecen :ref:`SubViewport.size_2d_override_stretch<class_SubViewport_property_size_2d_override_stretch>` y :ref:`SubViewport.size_2d_override<class_SubViewport_property_size_2d_override>`, se establece :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>` y el escalado está activado, se establece :ref:`oversampling_override<class_Viewport_property_oversampling_override>`, se activa el sobremuestreo de fuentes y el sobremuestreo de :ref:`DPITexture<class_DPITexture>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_oversampling_override:
.. rst-class:: classref-property
:ref:`float<class_float>` **oversampling_override** = ``0.0`` :ref:`🔗<class_Viewport_property_oversampling_override>`
.. rst-class:: classref-property-setget
- |void| **set_oversampling_override**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_oversampling_override**\ (\ )
Si es mayor que cero, este valor se utiliza como factor de sobremuestreo de la fuente, de lo contrario, el sobremuestreo es igual a la escala del viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_own_world_3d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **own_world_3d** = ``false`` :ref:`🔗<class_Viewport_property_own_world_3d>`
.. rst-class:: classref-property-setget
- |void| **set_use_own_world_3d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_own_world_3d**\ (\ )
Si es ``true``, el viewport utilizará una copia única del :ref:`World3D<class_World3D>` definido en :ref:`world_3d<class_Viewport_property_world_3d>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking**\ (\ )
Si es ``true``, los objetos renderizados por el viewport se convierten en sujetos del proceso de selección del ratón.
\ **Nota:** El número de objetos seleccionables simultáneamente está limitado a 64 y se seleccionan en un orden no determinista, que puede ser diferente en cada proceso de selección.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking_first_only:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking_first_only** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking_first_only>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking_first_only**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking_first_only**\ (\ )
Si es ``true``, la señal input_event solo se enviará a un objeto físico en el proceso de selección del ratón. Si quieres obtener solo el objeto superior, también debes habilitar :ref:`physics_object_picking_sort<class_Viewport_property_physics_object_picking_sort>`.
Si es ``false``, se enviará una señal input_event a todos los objetos físicos en el proceso de selección del ratón.
Esto se aplica solo a la selección de objetos 2D CanvasItem.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_physics_object_picking_sort:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **physics_object_picking_sort** = ``false`` :ref:`🔗<class_Viewport_property_physics_object_picking_sort>`
.. rst-class:: classref-property-setget
- |void| **set_physics_object_picking_sort**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_physics_object_picking_sort**\ (\ )
Si es ``true``, los objetos reciben los eventos de selección del ratón ordenados principalmente por su :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` y secundariamente por su posición en el árbol de escenas. Si es ``false``, el orden es indeterminado.
\ **Nota:** Esta configuración está deshabilitada por defecto debido a su potencial costo computacional.
\ **Nota:** La ordenación ocurre después de seleccionar los objetos seleccionables. Debido a la limitación de 64 objetos seleccionables simultáneamente, no se garantiza que el objeto con el :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` más alto reciba el evento de selección.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_16_bits:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **positional_shadow_atlas_16_bits** = ``true`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_16_bits>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_16_bits**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **get_positional_shadow_atlas_16_bits**\ (\ )
Use 16 bits for the omni/spot shadow depth map. Enabling this results in shadows having less precision and may result in shadow acne, but can lead to performance improvements on some devices.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_0:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_0** = ``2`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_0>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La cantidad de subdivisión del primer cuadrante del atlas de las sombras.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_1:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_1** = ``2`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_1>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La cantidad de subdivisión del segundo cuadrante en el atlas de las sombras.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_2:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_2** = ``3`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_2>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La cantidad de subdivisión del tercer cuadrante en el atlas de las sombras.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_quad_3:
.. rst-class:: classref-property
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **positional_shadow_atlas_quad_3** = ``4`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_quad_3>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ )
- :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const|
La cantidad de subdivisión del cuarto cuadrante en el atlas de las sombras.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_positional_shadow_atlas_size:
.. rst-class:: classref-property
:ref:`int<class_int>` **positional_shadow_atlas_size** = ``2048`` :ref:`🔗<class_Viewport_property_positional_shadow_atlas_size>`
.. rst-class:: classref-property-setget
- |void| **set_positional_shadow_atlas_size**\ (\ value\: :ref:`int<class_int>`\ )
- :ref:`int<class_int>` **get_positional_shadow_atlas_size**\ (\ )
La resolución del atlas de las sombras (usado para luces omni y spot). El valor se redondea a la potencia de 2 más cercana.
\ **Nota:** Si se establece a ``0``, ninguna sombra posicional será visible. Esto puede mejorar el rendimiento significativamente en sistemas de gama baja al reducir tanto la carga de la CPU como la de la GPU (ya que se necesitan menos llamadas de dibujado para dibujar la escena sin sombras).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_scaling_3d_mode:
.. rst-class:: classref-property
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **scaling_3d_mode** = ``0`` :ref:`🔗<class_Viewport_property_scaling_3d_mode>`
.. rst-class:: classref-property-setget
- |void| **set_scaling_3d_mode**\ (\ value\: :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>`\ )
- :ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **get_scaling_3d_mode**\ (\ )
Establece el modo de escalado 3D. El escalado bilineal renderiza a una resolución diferente para submuestrear o sobremuestrear el viewport. FidelityFX Super Resolution 1.0, abreviado como FSR, es una tecnología de reescalado que produce imágenes de alta calidad a velocidades de fotogramas rápidas mediante el uso de un algoritmo de reescalado espacialmente consciente. FSR es ligeramente más caro que el bilineal, pero produce una calidad de imagen significativamente mayor. FSR debe utilizarse siempre que sea posible.
Para controlar esta propiedad en el viewport raíz, establece la configuración del proyecto :ref:`ProjectSettings.rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_scaling_3d_scale:
.. rst-class:: classref-property
:ref:`float<class_float>` **scaling_3d_scale** = ``1.0`` :ref:`🔗<class_Viewport_property_scaling_3d_scale>`
.. rst-class:: classref-property-setget
- |void| **set_scaling_3d_scale**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_scaling_3d_scale**\ (\ )
Escala el búfer de renderizado 3D basándose en el tamaño del viewport. Utiliza un filtro de imagen especificado en :ref:`ProjectSettings.rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>` para escalar la imagen de salida al tamaño completo del viewport. Los valores inferiores a ``1.0`` pueden utilizarse para acelerar el renderizado 3D a costa de la calidad (submuestreo). Los valores superiores a ``1.0`` sólo son válidos para el modo bilineal y pueden utilizarse para mejorar la calidad del renderizado 3D a un alto coste de rendimiento (sobremuestreo). Véase también :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` para el antialiasing multi-muestra, que es significativamente más barato, pero sólo suaviza los bordes de los polígonos.
Cuando se utiliza el escalado FSR, AMD recomienda exponer los siguientes valores como opciones preestablecidas para los usuarios "Ultra Calidad: 0.77", "Calidad: 0.67", "Balanceado: 0.59", "Rendimiento: 0.5" en lugar de exponer la escala completa.
Para controlar esta propiedad en el viewport raíz, establece el ajuste del proyecto :ref:`ProjectSettings.rendering/scaling_3d/scale<class_ProjectSettings_property_rendering/scaling_3d/scale>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_screen_space_aa:
.. rst-class:: classref-property
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **screen_space_aa** = ``0`` :ref:`🔗<class_Viewport_property_screen_space_aa>`
.. rst-class:: classref-property-setget
- |void| **set_screen_space_aa**\ (\ value\: :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>`\ )
- :ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **get_screen_space_aa**\ (\ )
Establece el método de antialiasing del espacio de pantalla utilizado. El antialiasing del espacio de pantalla funciona difuminando selectivamente los bordes en un sombreador de post-proceso. Difiere del MSAA que toma múltiples muestras de cobertura al renderizar objetos. Los métodos AA del espacio de pantalla son típicamente más rápidos que el MSAA y suavizarán el aliasing especular, pero tienden a hacer que las escenas aparezcan borrosas.
Véase también :ref:`ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa<class_ProjectSettings_property_rendering/anti_aliasing/quality/screen_space_aa>` y :ref:`RenderingServer.viewport_set_screen_space_aa()<class_RenderingServer_method_viewport_set_screen_space_aa>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_sdf_oversize:
.. rst-class:: classref-property
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **sdf_oversize** = ``1`` :ref:`🔗<class_Viewport_property_sdf_oversize>`
.. rst-class:: classref-property-setget
- |void| **set_sdf_oversize**\ (\ value\: :ref:`SDFOversize<enum_Viewport_SDFOversize>`\ )
- :ref:`SDFOversize<enum_Viewport_SDFOversize>` **get_sdf_oversize**\ (\ )
Controla qué parte del tamaño del viewport original debe ser cubierta por el campo de distancia firmado 2D. Este SDF puede ser muestreado en shaders :ref:`CanvasItem<class_CanvasItem>` y también se utiliza para la colisión de :ref:`GPUParticles2D<class_GPUParticles2D>`. Los valores más altos permiten que las porciones de los oclusores situados fuera del viewport se tengan en cuenta en el campo de distancia firmado generado, a costa del rendimiento. Si observas que las partículas caen a través de los :ref:`LightOccluder2D<class_LightOccluder2D>`\ s cuando los oclusores salen del viewport, aumenta este ajuste.
El porcentaje se añade en cada eje y en ambos lados. Por ejemplo, con el :ref:`SDF_OVERSIZE_120_PERCENT<class_Viewport_constant_SDF_OVERSIZE_120_PERCENT>` por defecto, el campo de distancia firmado cubrirá el 20% del tamaño del viewport fuera del viewport en cada lado (arriba, derecha, abajo, izquierda).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_sdf_scale:
.. rst-class:: classref-property
:ref:`SDFScale<enum_Viewport_SDFScale>` **sdf_scale** = ``1`` :ref:`🔗<class_Viewport_property_sdf_scale>`
.. rst-class:: classref-property-setget
- |void| **set_sdf_scale**\ (\ value\: :ref:`SDFScale<enum_Viewport_SDFScale>`\ )
- :ref:`SDFScale<enum_Viewport_SDFScale>` **get_sdf_scale**\ (\ )
La escala de resolución a usar para el campo de distancia con signo 2D. Valores más altos conducen a un campo de distancia con signo más preciso y más estable a medida que la cámara se mueve, a costa del rendimiento.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_snap_2d_transforms_to_pixel:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **snap_2d_transforms_to_pixel** = ``false`` :ref:`🔗<class_Viewport_property_snap_2d_transforms_to_pixel>`
.. rst-class:: classref-property-setget
- |void| **set_snap_2d_transforms_to_pixel**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_2d_transforms_to_pixel_enabled**\ (\ )
Si es ``true``, los nodos :ref:`CanvasItem<class_CanvasItem>` se ajustarán internamente a píxeles completos. Su posición aún puede ser sub-pixel, pero los decimales no tendrán efecto. Esto puede llevar a una apariencia más nítida a costa de un movimiento menos suave, especialmente cuando el suavizado de :ref:`Camera2D<class_Camera2D>` está habilitado.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_snap_2d_vertices_to_pixel:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **snap_2d_vertices_to_pixel** = ``false`` :ref:`🔗<class_Viewport_property_snap_2d_vertices_to_pixel>`
.. rst-class:: classref-property-setget
- |void| **set_snap_2d_vertices_to_pixel**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_snap_2d_vertices_to_pixel_enabled**\ (\ )
Si es ``true``, los vértices de los nodos :ref:`CanvasItem<class_CanvasItem>` se ajustarán a píxeles completos. Solo afecta las posiciones finales de los vértices, no las transformaciones. Esto puede llevar a una apariencia más nítida a costa de un movimiento menos suave, especialmente cuando el suavizado de :ref:`Camera2D<class_Camera2D>` está habilitado.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_texture_mipmap_bias:
.. rst-class:: classref-property
:ref:`float<class_float>` **texture_mipmap_bias** = ``0.0`` :ref:`🔗<class_Viewport_property_texture_mipmap_bias>`
.. rst-class:: classref-property-setget
- |void| **set_texture_mipmap_bias**\ (\ value\: :ref:`float<class_float>`\ )
- :ref:`float<class_float>` **get_texture_mipmap_bias**\ (\ )
Afecta la nitidez final de la textura leyendo de un mipmap inferior o superior (también llamado "sesgo LOD de la textura"). Los valores negativos hacen que las texturas mipmapped sean más nítidas pero más granuladas cuando se ven a distancia, mientras que los valores positivos hacen que las texturas mipmapped sean más borrosas (incluso de cerca).
Activar el antialiasing temporal (:ref:`use_taa<class_Viewport_property_use_taa>`) aplicará automáticamente un desplazamiento de ``-0.5`` a este valor, mientras que activar FXAA (:ref:`screen_space_aa<class_Viewport_property_screen_space_aa>`) aplicará automáticamente un desplazamiento de ``-0.25`` a este valor. Si tanto TAA como FXAA están activados al mismo tiempo, se aplica un desplazamiento de ``-0.75`` a este valor.
\ **Nota:** Si :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>` es inferior a ``1.0`` (exclusivo), :ref:`texture_mipmap_bias<class_Viewport_property_texture_mipmap_bias>` se utiliza para ajustar el sesgo mipmap automático que se calcula internamente en función del factor de escala. La fórmula para esto es ``log2(scaling_3d_scale) + mipmap_bias``.
Para controlar esta propiedad en el viewport raíz, establece el ajuste del proyecto :ref:`ProjectSettings.rendering/textures/default_filters/texture_mipmap_bias<class_ProjectSettings_property_rendering/textures/default_filters/texture_mipmap_bias>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_transparent_bg:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **transparent_bg** = ``false`` :ref:`🔗<class_Viewport_property_transparent_bg>`
.. rst-class:: classref-property-setget
- |void| **set_transparent_background**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **has_transparent_background**\ (\ )
If ``true``, the viewport should render its background as transparent.
\ **Note:** Due to technical limitations, certain rendering features are disabled when a viewport has a transparent background. This currently applies to screen-space reflections, subsurface scattering, and depth of field.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_debanding:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_debanding** = ``false`` :ref:`🔗<class_Viewport_property_use_debanding>`
.. rst-class:: classref-property-setget
- |void| **set_use_debanding**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_debanding**\ (\ )
When using the Mobile or Forward+ renderers, set :ref:`use_debanding<class_Viewport_property_use_debanding>` to enable or disable the debanding feature of this **Viewport**. If :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``false``, 2D rendering is *not* affected by debanding unless the :ref:`Environment.background_mode<class_Environment_property_background_mode>` is :ref:`Environment.BG_CANVAS<class_Environment_constant_BG_CANVAS>`. If :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``true``, debanding will only be applied if this is the root **Viewport** and will affect all 2D and 3D rendering, including canvas items.
\ :ref:`use_debanding<class_Viewport_property_use_debanding>` has no effect when using the Compatibility rendering method. The Mobile renderer can also use material debanding, which can be set with :ref:`RenderingServer.material_set_use_debanding()<class_RenderingServer_method_material_set_use_debanding>` or configured with :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_debanding<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_debanding>`.
See also :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_debanding<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_debanding>`, :ref:`RenderingServer.material_set_use_debanding()<class_RenderingServer_method_material_set_use_debanding>`, and :ref:`RenderingServer.viewport_set_use_debanding()<class_RenderingServer_method_viewport_set_use_debanding>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_hdr_2d:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_hdr_2d** = ``false`` :ref:`🔗<class_Viewport_property_use_hdr_2d>`
.. rst-class:: classref-property-setget
- |void| **set_use_hdr_2d**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_hdr_2d**\ (\ )
If ``true``, 2D rendering will use a high dynamic range (HDR) ``RGBA16`` format framebuffer. Additionally, 2D rendering will be performed on linear values and will be converted using the appropriate transfer function immediately before blitting to the screen (if the Viewport is attached to the screen).
Practically speaking, this means that the end result of the Viewport will not be clamped to the ``0-1`` range and can be used in 3D rendering without color encoding adjustments. This allows 2D rendering to take advantage of effects requiring high dynamic range (e.g. 2D glow) as well as substantially improves the appearance of effects requiring highly detailed gradients.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_occlusion_culling:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_occlusion_culling** = ``false`` :ref:`🔗<class_Viewport_property_use_occlusion_culling>`
.. rst-class:: classref-property-setget
- |void| **set_use_occlusion_culling**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_occlusion_culling**\ (\ )
Si es ``true``, los nodos :ref:`OccluderInstance3D<class_OccluderInstance3D>` se podrán utilizar para el culling por oclusión en 3D para este viewport. Para el viewport raíz, en su lugar se debe establecer :ref:`ProjectSettings.rendering/occlusion_culling/use_occlusion_culling<class_ProjectSettings_property_rendering/occlusion_culling/use_occlusion_culling>` a ``true``.
\ **Nota:** Activar el culling por oclusión tiene un coste en la CPU. Sólo activa el culling por oclusión si realmente planeas usarlo, y piensa si tu escena puede realmente beneficiarse del culling por oclusión. Las escenas grandes y abiertas con pocos o ningún objeto que bloquee la vista generalmente no se benefician mucho del culling por oclusión. Las escenas grandes y abiertas generalmente se benefician más del LOD de la malla y los rangos de visibilidad (:ref:`GeometryInstance3D.visibility_range_begin<class_GeometryInstance3D_property_visibility_range_begin>` y :ref:`GeometryInstance3D.visibility_range_end<class_GeometryInstance3D_property_visibility_range_end>`) en comparación con el culling por oclusión.
\ **Nota:** Debido a las limitaciones de memoria, el culling por oclusión no es compatible por defecto en las plantillas de exportación Web. Se puede activar compilando plantillas de exportación Web personalizadas con ``module_raycast_enabled=yes``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_taa:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_taa** = ``false`` :ref:`🔗<class_Viewport_property_use_taa>`
.. rst-class:: classref-property-setget
- |void| **set_use_taa**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_taa**\ (\ )
Activa el antialiasing temporal para este viewport. TAA funciona haciendo vibrar la cámara y acumulando las imágenes de los últimos fotogramas renderizados, se utiliza el renderizado de vectores de movimiento para tener en cuenta el movimiento de la cámara y de los objetos.
\ **Nota:** La implementación aún no está completa, algunas instancias visuales como las partículas y las mallas skinneadas pueden mostrar artefactos.
Véase también :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_taa<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_taa>` y :ref:`RenderingServer.viewport_set_use_taa()<class_RenderingServer_method_viewport_set_use_taa>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_use_xr:
.. rst-class:: classref-property
:ref:`bool<class_bool>` **use_xr** = ``false`` :ref:`🔗<class_Viewport_property_use_xr>`
.. rst-class:: classref-property-setget
- |void| **set_use_xr**\ (\ value\: :ref:`bool<class_bool>`\ )
- :ref:`bool<class_bool>` **is_using_xr**\ (\ )
Si es ``true``, el viewport utilizará la interfaz XR principal para renderizar la salida XR. Cuando sea aplicable, esto puede resultar en una imagen estereoscópica y el renderizado resultante se enviará a un casco.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_mode:
.. rst-class:: classref-property
:ref:`VRSMode<enum_Viewport_VRSMode>` **vrs_mode** = ``0`` :ref:`🔗<class_Viewport_property_vrs_mode>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_mode**\ (\ value\: :ref:`VRSMode<enum_Viewport_VRSMode>`\ )
- :ref:`VRSMode<enum_Viewport_VRSMode>` **get_vrs_mode**\ (\ )
El modo de Sombreado de Tasa Variable (VRS) que se utiliza para este viewport. Nota, si el hardware no soporta VRS esta propiedad se ignora.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_texture:
.. rst-class:: classref-property
:ref:`Texture2D<class_Texture2D>` **vrs_texture** :ref:`🔗<class_Viewport_property_vrs_texture>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_texture**\ (\ value\: :ref:`Texture2D<class_Texture2D>`\ )
- :ref:`Texture2D<class_Texture2D>` **get_vrs_texture**\ (\ )
Textura a usar cuando :ref:`vrs_mode<class_Viewport_property_vrs_mode>` se establece en :ref:`VRS_TEXTURE<class_Viewport_constant_VRS_TEXTURE>`.
La textura *debe* usar un formato de compresión sin pérdida para que los colores se puedan emparejar con precisión. Las siguientes densidades de VRS se asignan a varios colores, donde los colores más brillantes representan un nivel más bajo de precisión de sombreado:
.. code:: text
- 1×1 = rgb(0, 0, 0) - #000000
- 1×2 = rgb(0, 85, 0) - #005500
- 2×1 = rgb(85, 0, 0) - #550000
- 2×2 = rgb(85, 85, 0) - #555500
- 2×4 = rgb(85, 170, 0) - #55aa00
- 4×2 = rgb(170, 85, 0) - #aa5500
- 4×4 = rgb(170, 170, 0) - #aaaa00
- 4×8 = rgb(170, 255, 0) - #aaff00 - No soportado en la mayoría del hardware
- 8×4 = rgb(255, 170, 0) - #ffaa00 - No soportado en la mayoría del hardware
- 8×8 = rgb(255, 255, 0) - #ffff00 - No soportado en la mayoría del hardware
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_vrs_update_mode:
.. rst-class:: classref-property
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **vrs_update_mode** = ``1`` :ref:`🔗<class_Viewport_property_vrs_update_mode>`
.. rst-class:: classref-property-setget
- |void| **set_vrs_update_mode**\ (\ value\: :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>`\ )
- :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **get_vrs_update_mode**\ (\ )
Establece el modo de actualización del Sombreado de Tasa Variable (VRS) para el viewport. El VRS requiere que la textura de entrada sea convertida al formato utilizable por el método VRS soportado por el hardware. El modo de actualización define la frecuencia con que esto ocurre. Si la GPU no soporta VRS, o el VRS no está habilitado, esta propiedad es ignorada.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_world_2d:
.. rst-class:: classref-property
:ref:`World2D<class_World2D>` **world_2d** :ref:`🔗<class_Viewport_property_world_2d>`
.. rst-class:: classref-property-setget
- |void| **set_world_2d**\ (\ value\: :ref:`World2D<class_World2D>`\ )
- :ref:`World2D<class_World2D>` **get_world_2d**\ (\ )
La :ref:`World2D<class_World2D>` personalizada que puede ser usada como fuente de entorno 2D.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_property_world_3d:
.. rst-class:: classref-property
:ref:`World3D<class_World3D>` **world_3d** :ref:`🔗<class_Viewport_property_world_3d>`
.. rst-class:: classref-property-setget
- |void| **set_world_3d**\ (\ value\: :ref:`World3D<class_World3D>`\ )
- :ref:`World3D<class_World3D>` **get_world_3d**\ (\ )
El :ref:`World3D<class_World3D>` personalizado que se puede usar como fuente de entorno 3D.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _class_Viewport_method_find_world_2d:
.. rst-class:: classref-method
:ref:`World2D<class_World2D>` **find_world_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_find_world_2d>`
Devuelve el primer :ref:`World2D<class_World2D>` válido para este viewport, buscando en la propiedad :ref:`world_2d<class_Viewport_property_world_2d>` de sí mismo y de cualquier ancestro Viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_find_world_3d:
.. rst-class:: classref-method
:ref:`World3D<class_World3D>` **find_world_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_find_world_3d>`
Devuelve el primer :ref:`World3D<class_World3D>` válido para este viewport, buscando en la propiedad :ref:`world_3d<class_Viewport_property_world_3d>` de sí mismo y de cualquier ancestro Viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_audio_listener_2d:
.. rst-class:: classref-method
:ref:`AudioListener2D<class_AudioListener2D>` **get_audio_listener_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_audio_listener_2d>`
Devuelve el oyente de audio 2D activo. Devuelve ``null`` si no hay oyentes de audio 2D activos, en cuyo caso la cámara 2D activa será tratada como oyente.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_audio_listener_3d:
.. rst-class:: classref-method
:ref:`AudioListener3D<class_AudioListener3D>` **get_audio_listener_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_audio_listener_3d>`
Devuelve el oyente de audio 3D activo. Devuelve ``null`` si no hay oyentes de audio 3D activos, en cuyo caso la cámara 3D activa será tratada como oyente.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_camera_2d:
.. rst-class:: classref-method
:ref:`Camera2D<class_Camera2D>` **get_camera_2d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_camera_2d>`
Returns the currently active 2D camera. Returns ``null`` if there are no active cameras.
\ **Note:** If called while the *Camera Override* system is active in editor, this will return the internally managed override camera. It is therefore advised to avoid caching the return value, or to check that the cached value is still a valid instance and is the current camera before use. See :ref:`@GlobalScope.is_instance_valid()<class_@GlobalScope_method_is_instance_valid>` and :ref:`Camera2D.is_current()<class_Camera2D_method_is_current>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_camera_3d:
.. rst-class:: classref-method
:ref:`Camera3D<class_Camera3D>` **get_camera_3d**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_camera_3d>`
Returns the currently active 3D camera. Returns ``null`` if there are no active cameras.
\ **Note:** If called while the *Camera Override* system is active in editor, this will return the internally managed override camera. It is therefore advised to avoid caching the return value, or to check that the cached value is a valid instance and is the current camera before use. See :ref:`@GlobalScope.is_instance_valid()<class_@GlobalScope_method_is_instance_valid>` and :ref:`Camera3D.current<class_Camera3D_property_current>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_canvas_cull_mask_bit:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_canvas_cull_mask_bit**\ (\ layer\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Viewport_method_get_canvas_cull_mask_bit>`
Devuelve un bit individual en la máscara de capa de renderizado.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_embedded_subwindows:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`Window<class_Window>`\] **get_embedded_subwindows**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_embedded_subwindows>`
Devuelve una lista de las :ref:`Window<class_Window>`\ s embebidas visibles dentro del viewport.
\ **Nota:** Las :ref:`Window<class_Window>`\ s dentro de otros viewports no serán listadas.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_final_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_final_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_final_transform>`
Devuelve la transformación del sistema de coordenadas del viewport al sistema de coordenadas del embebedor.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_mouse_position:
.. rst-class:: classref-method
:ref:`Vector2<class_Vector2>` **get_mouse_position**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_mouse_position>`
Devuelve la posición del ratón en este **Viewport** utilizando el sistema de coordenadas de este **Viewport**.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_oversampling:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_oversampling**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_oversampling>`
Devuelve el factor de sobremuestreo del viewport.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv:
.. rst-class:: classref-method
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **get_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Viewport_method_get_positional_shadow_atlas_quadrant_subdiv>`
Devuelve la subdivisión del cuadrante del atlas de sombras posicionales del cuadrante especificado.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_render_info:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_render_info**\ (\ type\: :ref:`RenderInfoType<enum_Viewport_RenderInfoType>`, info\: :ref:`RenderInfo<enum_Viewport_RenderInfo>`\ ) :ref:`🔗<class_Viewport_method_get_render_info>`
Devuelve estadísticas de representación del tipo dado.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_screen_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_screen_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_screen_transform>`
Devuelve la transformación de las coordenadas del Viewport a las coordenadas de la pantalla de la ventana del gestor de ventanas que la contiene.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_stretch_transform:
.. rst-class:: classref-method
:ref:`Transform2D<class_Transform2D>` **get_stretch_transform**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_stretch_transform>`
Devuelve la transformación de estiramiento 2D calculada automáticamente, teniendo en cuenta los ajustes de estiramiento del **Viewport**. El valor final se multiplica por :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>`, pero sólo para el viewport raíz. Si este método se llama en un :ref:`SubViewport<class_SubViewport>` (por ejemplo, en un árbol de escena con :ref:`SubViewportContainer<class_SubViewportContainer>` y :ref:`SubViewport<class_SubViewport>`), el factor de escala de la ventana raíz no se aplicará. Usando :ref:`Transform2D.get_scale()<class_Transform2D_method_get_scale>` en el valor devuelto, esto puede ser usado para compensar el escalado al hacer zoom en un nodo :ref:`Camera2D<class_Camera2D>`, o para escalar un :ref:`TextureRect<class_TextureRect>` para que sea perfecto en píxeles independientemente del factor de escala calculado automáticamente.
\ **Nota:** Debido a cómo funciona el escalado de píxeles, la escala X e Y de la transformación devuelta puede diferir ligeramente, incluso cuando :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` se establece en un modo que conserva la relación de aspecto de los píxeles. Si :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` es :ref:`Window.CONTENT_SCALE_ASPECT_IGNORE<class_Window_constant_CONTENT_SCALE_ASPECT_IGNORE>`, la escala X e Y puede diferir *significativamente*.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_texture:
.. rst-class:: classref-method
:ref:`ViewportTexture<class_ViewportTexture>` **get_texture**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_texture>`
Returns the viewport's texture.
\ **Note:** When trying to store the current texture (e.g. in a file), it might be completely black or outdated if used too early, especially when used in e.g. :ref:`Node._ready()<class_Node_private_method__ready>`. To make sure the texture you get is correct, you can await :ref:`RenderingServer.frame_post_draw<class_RenderingServer_signal_frame_post_draw>` signal.
.. tabs::
.. code-tab:: gdscript
func _ready():
await RenderingServer.frame_post_draw
$Viewport.get_texture().get_image().save_png("user://Screenshot.png")
.. code-tab:: csharp
public async override void _Ready()
{
await ToSignal(RenderingServer.Singleton, RenderingServer.SignalName.FramePostDraw);
var viewport = GetNode<Viewport>("Viewport");
viewport.GetTexture().GetImage().SavePng("user://Screenshot.png");
}
\ **Note:** When :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` is ``true`` the returned texture will be an HDR image using linear encoding.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_viewport_rid:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **get_viewport_rid**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_viewport_rid>`
Devuelve el RID del viewport del :ref:`RenderingServer<class_RenderingServer>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_get_visible_rect:
.. rst-class:: classref-method
:ref:`Rect2<class_Rect2>` **get_visible_rect**\ (\ ) |const| :ref:`🔗<class_Viewport_method_get_visible_rect>`
Returns the visible rectangle in global screen coordinates.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_cancel_drag:
.. rst-class:: classref-method
|void| **gui_cancel_drag**\ (\ ) :ref:`🔗<class_Viewport_method_gui_cancel_drag>`
Cancela la operación de arrastre que se inició previamente a través de :ref:`Control._get_drag_data()<class_Control_private_method__get_drag_data>` o se forzó con :ref:`Control.force_drag()<class_Control_method_force_drag>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_drag_data:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **gui_get_drag_data**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_drag_data>`
Devuelve los datos de arrastre de la GUI, que fueron previamente devueltos por :ref:`Control._get_drag_data()<class_Control_private_method__get_drag_data>`.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_drag_description:
.. rst-class:: classref-method
:ref:`String<class_String>` **gui_get_drag_description**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_drag_description>`
Returns the human-readable description of the drag data, used for assistive apps.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_focus_owner:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **gui_get_focus_owner**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_focus_owner>`
Devuelve el :ref:`Control<class_Control>` actualmente enfocado dentro de este viewport. Si no hay ningún :ref:`Control<class_Control>` enfocado, devuelve ``null``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_get_hovered_control:
.. rst-class:: classref-method
:ref:`Control<class_Control>` **gui_get_hovered_control**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_get_hovered_control>`
Devuelve el :ref:`Control<class_Control>` sobre el que el ratón está actualmente en este viewport. Si ningún :ref:`Control<class_Control>` tiene el cursor, devuelve ``null``.
Típicamente el nodo :ref:`Control<class_Control>` hoja o el nivel más profundo del subárbol que reclama el hover. Esto es muy útil cuando se usa junto con :ref:`Node.is_ancestor_of()<class_Node_method_is_ancestor_of>` para encontrar si el ratón está dentro de un árbol de control.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_is_drag_successful:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **gui_is_drag_successful**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_is_drag_successful>`
Devuelve ``true`` si la operación de arrastre es exitosa.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_is_dragging:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **gui_is_dragging**\ (\ ) |const| :ref:`🔗<class_Viewport_method_gui_is_dragging>`
Devuelve ``true`` si una operación de arrastre está actualmente en curso y donde la acción de soltar podría ocurrir en este viewport.
Alternativa a :ref:`Node.NOTIFICATION_DRAG_BEGIN<class_Node_constant_NOTIFICATION_DRAG_BEGIN>` y :ref:`Node.NOTIFICATION_DRAG_END<class_Node_constant_NOTIFICATION_DRAG_END>` cuando se prefiere sondear el valor.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_release_focus:
.. rst-class:: classref-method
|void| **gui_release_focus**\ (\ ) :ref:`🔗<class_Viewport_method_gui_release_focus>`
Quita el foco del :ref:`Control<class_Control>` actualmente enfocado dentro de este viewport. Si ningún :ref:`Control<class_Control>` tiene el foco, no hace nada.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_gui_set_drag_description:
.. rst-class:: classref-method
|void| **gui_set_drag_description**\ (\ description\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Viewport_method_gui_set_drag_description>`
Sets the human-readable description of the drag data to ``description``, used for assistive apps.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_is_input_handled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_input_handled**\ (\ ) |const| :ref:`🔗<class_Viewport_method_is_input_handled>`
Devuelve si el :ref:`InputEvent<class_InputEvent>` actual ha sido manejado. Los eventos de entrada no se manejan hasta que se ha llamado a :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` durante la vida útil de un :ref:`InputEvent<class_InputEvent>`.
Esto se hace normalmente como parte de los métodos de manejo de entrada como :ref:`Node._input()<class_Node_private_method__input>`, :ref:`Control._gui_input()<class_Control_private_method__gui_input>` u otros, así como en los manejadores de señales correspondientes.
Si :ref:`handle_input_locally<class_Viewport_property_handle_input_locally>` se establece en ``false``, este método intentará encontrar el primer viewport padre que esté configurado para manejar la entrada localmente, y devolverá su valor para :ref:`is_input_handled()<class_Viewport_method_is_input_handled>` en su lugar.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_notify_mouse_entered:
.. rst-class:: classref-method
|void| **notify_mouse_entered**\ (\ ) :ref:`🔗<class_Viewport_method_notify_mouse_entered>`
Informa al Viewport de que el ratón ha entrado en su área. Utiliza esta función antes de enviar un :ref:`InputEventMouseButton<class_InputEventMouseButton>` o :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` al **Viewport** con :ref:`push_input()<class_Viewport_method_push_input>`. Véase también :ref:`notify_mouse_exited()<class_Viewport_method_notify_mouse_exited>`.
\ **Nota:** En la mayoría de los casos, no es necesario llamar a esta función porque los nodos :ref:`SubViewport<class_SubViewport>` que son hijos de :ref:`SubViewportContainer<class_SubViewportContainer>` son notificados automáticamente. Esto sólo es necesario cuando se interactúa con viewports de forma no predeterminada, por ejemplo, como texturas en :ref:`TextureRect<class_TextureRect>` o con un :ref:`Area3D<class_Area3D>` que reenvía los eventos de entrada.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_notify_mouse_exited:
.. rst-class:: classref-method
|void| **notify_mouse_exited**\ (\ ) :ref:`🔗<class_Viewport_method_notify_mouse_exited>`
Informa al Viewport de que el ratón ha salido de su área. Utiliza esta función cuando el nodo que muestra el viewport note que el ratón ha salido del área del viewport mostrado. Véase también :ref:`notify_mouse_entered()<class_Viewport_method_notify_mouse_entered>`.
\ **Nota:** En la mayoría de los casos, no es necesario llamar a esta función porque los nodos :ref:`SubViewport<class_SubViewport>` que son hijos de :ref:`SubViewportContainer<class_SubViewportContainer>` son notificados automáticamente. Esto sólo es necesario cuando se interactúa con viewports de forma no predeterminada, por ejemplo, como texturas en :ref:`TextureRect<class_TextureRect>` o con un :ref:`Area3D<class_Area3D>` que reenvía los eventos de entrada.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_input:
.. rst-class:: classref-method
|void| **push_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Viewport_method_push_input>`
Activa el ``event`` dado en este **Viewport**. Esto puede ser usado para pasar un :ref:`InputEvent<class_InputEvent>` entre viewports, o para aplicar localmente entradas que fueron enviadas por la red o guardadas en un archivo.
Si ``in_local_coords`` es ``false``, la posición del evento está en las coordenadas del incrustador y será convertida a coordenadas del viewport. Si ``in_local_coords`` es ``true``, la posición del evento está en coordenadas del viewport.
Aunque este método tiene un propósito similar a :ref:`Input.parse_input_event()<class_Input_method_parse_input_event>`, no reasigna el ``event`` especificado basado en los ajustes del proyecto como :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
Llamar a este método propagará las llamadas a los nodos hijo para los siguientes métodos en el orden dado:
- :ref:`Node._input()<class_Node_private_method__input>`\
- :ref:`Control._gui_input()<class_Control_private_method__gui_input>` para nodos :ref:`Control<class_Control>`\
- :ref:`Node._shortcut_input()<class_Node_private_method__shortcut_input>`\
- :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`\
- :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>`\
Si un método anterior marca la entrada como manejada vía :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, cualquier método posterior en esta lista no será llamado.
Si ninguno de los métodos maneja el evento y :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` es ``true``, el evento es usado para la selección de objetos de física.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_text_input:
.. rst-class:: classref-method
|void| **push_text_input**\ (\ text\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Viewport_method_push_text_input>`
Método auxiliar que llama al método ``set_text()`` en el :ref:`Control<class_Control>` actualmente enfocado, siempre que esté definido (por ejemplo, si el Control enfocado es :ref:`Button<class_Button>` o :ref:`LineEdit<class_LineEdit>`).
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_push_unhandled_input:
.. rst-class:: classref-method
|void| **push_unhandled_input**\ (\ event\: :ref:`InputEvent<class_InputEvent>`, in_local_coords\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Viewport_method_push_unhandled_input>`
**Obsoleto:** Use :ref:`push_input()<class_Viewport_method_push_input>` instead.
Activa el ``event`` dado en este **Viewport**. Esto puede ser usado para pasar un :ref:`InputEvent<class_InputEvent>` entre viewports, o para aplicar localmente entradas que fueron enviadas por la red o guardadas en un archivo.
Si ``in_local_coords`` es ``false``, la posición del evento está en las coordenadas del incrustador y será convertida a coordenadas del viewport. Si ``in_local_coords`` es ``true``, la posición del evento está en coordenadas del viewport.
Llamar a este método propagará las llamadas a los nodos hijo para los siguientes métodos en el orden dado:
- :ref:`Node._shortcut_input()<class_Node_private_method__shortcut_input>`\
- :ref:`Node._unhandled_key_input()<class_Node_private_method__unhandled_key_input>`\
- :ref:`Node._unhandled_input()<class_Node_private_method__unhandled_input>`\
Si un método anterior marca la entrada como manejada vía :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, cualquier método posterior en esta lista no será llamado.
Si ninguno de los métodos maneja el evento y :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` es ``true``, el evento es usado para la selección de objetos de física.
\ **Nota:** Este método no propaga los eventos de entrada a :ref:`Window<class_Window>`\ s o :ref:`SubViewport<class_SubViewport>`\ s incrustados.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_canvas_cull_mask_bit:
.. rst-class:: classref-method
|void| **set_canvas_cull_mask_bit**\ (\ layer\: :ref:`int<class_int>`, enable\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_Viewport_method_set_canvas_cull_mask_bit>`
Establece o borra bits individuales en la máscara de la capa de renderizado. Esto simplifica la edición de las capas de este **Viewport**.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_input_as_handled:
.. rst-class:: classref-method
|void| **set_input_as_handled**\ (\ ) :ref:`🔗<class_Viewport_method_set_input_as_handled>`
Stops the input from propagating further up the :ref:`SceneTree<class_SceneTree>`.
\ **Note:** This does not affect the methods in :ref:`Input<class_Input>`, only the way events are propagated.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv:
.. rst-class:: classref-method
|void| **set_positional_shadow_atlas_quadrant_subdiv**\ (\ quadrant\: :ref:`int<class_int>`, subdiv\: :ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>`\ ) :ref:`🔗<class_Viewport_method_set_positional_shadow_atlas_quadrant_subdiv>`
Establece el número de subdivisiones a utilizar en el cuadrante especificado. Un mayor número de subdivisiones permite tener más sombras en la escena a la vez, pero reduce la calidad de las sombras. Una buena práctica es tener cuadrantes con un número variable de subdivisiones y tener el menor número posible de subdivisiones.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_update_mouse_cursor_state:
.. rst-class:: classref-method
|void| **update_mouse_cursor_state**\ (\ ) :ref:`🔗<class_Viewport_method_update_mouse_cursor_state>`
Fuerza la actualización instantánea de la visualización basándose en la posición actual del cursor del ratón. Esto incluye la actualización de la forma del cursor del ratón y el envío de las señales necesarias :ref:`Control.mouse_entered<class_Control_signal_mouse_entered>`, :ref:`CollisionObject2D.mouse_entered<class_CollisionObject2D_signal_mouse_entered>`, :ref:`CollisionObject3D.mouse_entered<class_CollisionObject3D_signal_mouse_entered>` y :ref:`Window.mouse_entered<class_Window_signal_mouse_entered>` y sus contrapartes ``mouse_exited``.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_method_warp_mouse:
.. rst-class:: classref-method
|void| **warp_mouse**\ (\ position\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_Viewport_method_warp_mouse>`
Mueve el puntero del ratón a la posición especificada en este **Viewport** utilizando el sistema de coordenadas de este **Viewport**.
\ **Nota:** :ref:`warp_mouse()<class_Viewport_method_warp_mouse>` sólo es compatible con Windows, macOS y Linux. No tiene ningún efecto en Android, iOS y Web.
.. |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