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.5
godot-docs-l10n/classes/fr/class_viewport.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

2683 lines
166 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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
========
**Hérite de :** :ref:`Node<class_Node>` **<** :ref:`Object<class_Object>`
**Hérité par :** :ref:`SubViewport<class_SubViewport>`, :ref:`Window<class_Window>`
Classe de base abstraite pour les viewports. Encapsule le dessin et l'interaction avec un monde de jeu.
.. rst-class:: classref-introduction-group
Description
-----------
Un **Viewport** crée une vue différente à l'écran, ou une sous-vue à l'intérieur d'un autre viewport. Les nœuds 2D enfants s'afficheront dessus, et les nœuds 3D Camera3D enfants rendront également dessus.
Optionnellement, un viewport peut avoir son propre monde 2D ou 3D, donc il ne partage pas ce qu'il dessine avec d'autres viewports.
Des viewports peuvent également choisir d'être des auditeurs audio, donc ils génèrent de l'audio positionnel en fonction d'une camera enfant 2D ou 3D.
De plus, des viewports peuvent être affectés à différents écrans au cas où les appareils ont plusieurs écrans.
Enfin, les viewports peuvent aussi se comporter comme des cibles de rendu, auquel cas ils ne seront pas visibles à moins que la texture associée ne soit utilisée pour dessiner.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- :doc:`Utilisation des Viewports <../tutorials/rendering/viewports>`
- :doc:`Transformations du canevas et de la fenêtre d'affichage <../tutorials/2d/2d_transforms>`
- `Démo de GUI dans un Viewport 3D <https://godotengine.org/asset-library/asset/2807>`__
- `Démo pour de la 3D dans un viewport 2D <https://godotengine.org/asset-library/asset/2804>`__
- `Démo pour de la 2D dans un viewport 3D <https://godotengine.org/asset-library/asset/2803>`__
- `Démo de capture d'écran <https://godotengine.org/asset-library/asset/2808>`__
- `Démo de l'écran partagé dynamique <https://godotengine.org/asset-library/asset/2806>`__
- `Démo de redimensionnement de la résolution 3D <https://godotengine.org/asset-library/asset/2805>`__
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. 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:`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éthodes
----------------
.. 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
Signaux
--------------
.. _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>`
Émis lorsqu'un nœud Control récupère le focus du clavier.
\ **Note :** Un nœud Control perdant le focus ne provoque pas l'émission de ce signal.
.. rst-class:: classref-item-separator
----
.. _class_Viewport_signal_size_changed:
.. rst-class:: classref-signal
**size_changed**\ (\ ) :ref:`🔗<class_Viewport_signal_size_changed>`
Émis lorsque la taille du viewport a changé, que ce soit en redimensionnant la fenêtre, ou par d'autres moyens.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _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``
Ce quadrant ne sera pas utilisé.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1** = ``1``
Ce quadrant ne sera utilisé que par une seule shadow map.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_4:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_4** = ``2``
Ce quadrant sera découpé en 4, et utilisé par jusqu'à 4 shadow maps.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_16:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_16** = ``3``
Ce quadrant sera découpé en 16, et utilisé par jusqu'à 16 shadow maps.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_64:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_64** = ``4``
Ce quadrant sera découpé en 64, et utilisé par jusqu'à 64 shadow maps.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_256:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_256** = ``5``
Ce quadrant sera découpé en 256, et utilisé par jusqu'à 256 shadow maps. Sauf si :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` est très élevé, les ombres dans ce quadrant seront à très basse résolution.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_1024:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_1024** = ``6``
Ce quadrant sera découpé en 1024, et utilisé par jusqu'à 1024 shadow maps. Sauf si :ref:`positional_shadow_atlas_size<class_Viewport_property_positional_shadow_atlas_size>` est très élevé, les ombres de ce quadrant seront à très basse résolution.
.. _class_Viewport_constant_SHADOW_ATLAS_QUADRANT_SUBDIV_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`PositionalShadowAtlasQuadrantSubdiv<enum_Viewport_PositionalShadowAtlasQuadrantSubdiv>` **SHADOW_ATLAS_QUADRANT_SUBDIV_MAX** = ``7``
Représente la taille de l'énumération :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``
Utiliser une mise à l'échelle bilinéaire pour le buffer 3D du viewport. L'échelle peut être définie en utilisant :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Les valeurs inférieures à ``1.0`` entraîneront un sous-échantillonnage tandis que les valeurs supérieures à ``1.0`` entraîneront un sur-échantillonage. Une valeur de ``1.0`` désactive la mise à l'échelle.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR** = ``1``
Utiliser l'upscaling AMD Fidelity FX Super Resolution 1.0 pour le buffer 3D du viewport. La quantité d'échelle peut être définie en utilisant :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Les valeurs inférieures à ``1.0`` résulteront en l'upscaling du viewport en utilisant le FSR. Les valeurs supérieures à ``1.0`` ne sont pas supportées et l'échantillonnage bilinéaire sera utilisé à la place. Une valeur de ``1.0`` désactive la mise à l'échelle.
.. _class_Viewport_constant_SCALING_3D_MODE_FSR2:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_FSR2** = ``2``
Utiliser la mise à l'échelle AMD Fidelity FX Super Resolution 2.2 pour le buffer 3D du viewport. L'échelle peut être définie en utilisant :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. Les valeurs inférieures à ``1.0`` résulteront en la mise à l'échelle du viewport en utilisant la FSR2. Les valeurs supérieures à ``1.0`` ne sont pas supportées et un échantillonnage bilinéaire sera utilisé à la place. Une valeur de ``1.0`` utilisera la FSR2 en résolution native comme solution 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``
Utiliser l'`upscaler spatial MetalFX <https://developer.apple.com/documentation/metalfx/mtlfxspatialscaler#overview>`__ pour le buffer 3D du viewport.
La quantité d'échelle peut être définie en utilisant :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`.
Les valeurs inférieures à ``1.0`` résulteront en l'upscaling du viewport en utilisant MetalFX. Les valeurs supérieures à ``1.0`` ne sont pas supportées et l'échantillonnage bilinéaire sera utilisé à la place. Une valeur de ``1.0`` désactive la mise à l'échelle.
Plus d'informations : `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Note :** Seulement supporté lorsque le pilote de rendu Metal est utilisé, ce qui limite ce mode d'échelle à macOS et 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``
Use the `MetalFX temporal upscaler <https://developer.apple.com/documentation/metalfx/mtlfxtemporalscaler#overview>`__ for the viewport's 3D buffer.
The amount of scaling can be set using :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>`. To determine the minimum input scale, use the :ref:`RenderingDevice.limit_get()<class_RenderingDevice_method_limit_get>` method with :ref:`RenderingDevice.LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE<class_RenderingDevice_constant_LIMIT_METALFX_TEMPORAL_SCALER_MIN_SCALE>`.
Values less than ``1.0`` will result in the viewport being upscaled using MetalFX. Values greater than ``1.0`` are not supported and bilinear downsampling will be used instead. A value of ``1.0`` will use MetalFX at native resolution as a TAA solution.
More information: `MetalFX <https://developer.apple.com/documentation/metalfx>`__.
\ **Note:** Only supported when the Metal rendering driver is in use, which limits this scaling mode to macOS and iOS.
.. _class_Viewport_constant_SCALING_3D_MODE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Scaling3DMode<enum_Viewport_Scaling3DMode>` **SCALING_3D_MODE_MAX** = ``5``
Représente la taille de l'énumération :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``
Mode d’anticrénelage multi-échantillion désactivé. Il s'agit de la valeur par défaut, et aussi du paramètre le plus rapide.
.. _class_Viewport_constant_MSAA_2X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_2X** = ``1``
Utiliser l'anti-crénelage multi-échantillion ×2 (×2 MSAA). Cela a un coût de performance modéré. Il aide à réduire le crénelage de façon notable, mais le MSAA 4× est toujours beaucoup plus beau.
.. _class_Viewport_constant_MSAA_4X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_4X** = ``2``
Utiliser l'anti-crénelage multi-échantillion ×4 (×4 MSAA). Cela a un coût de performance significatif, et est généralement un bon compromis entre performances et qualité.
.. _class_Viewport_constant_MSAA_8X:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_8X** = ``3``
Utiliser l'anti-crénelage multi-échantillion ×8 (×8 MSAA). Cela a un très haut coût sur les performances. La différence entre la MSAA ×4 et ×8 n'est pas toujours visible en condition de gameplay réelles. Probablement non supporté sur du matériel ancien ou bas de gamme.
.. _class_Viewport_constant_MSAA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`MSAA<enum_Viewport_MSAA>` **MSAA_MAX** = ``4``
Représente la taille de l'énumération :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``
Le filtrage anisotrope est désactivé.
.. _class_Viewport_constant_ANISOTROPY_2X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_2X** = ``1``
Utiliser le filtrage anisotrope x2.
.. _class_Viewport_constant_ANISOTROPY_4X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_4X** = ``2``
Utiliser le filtrage anisotrope x4. Il s’agit de la valeur par défaut.
.. _class_Viewport_constant_ANISOTROPY_8X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_8X** = ``3``
Utiliser le filtrage anisotrope x8.
.. _class_Viewport_constant_ANISOTROPY_16X:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_16X** = ``4``
Utiliser la filtrage anisotrope x16.
.. _class_Viewport_constant_ANISOTROPY_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`AnisotropicFiltering<enum_Viewport_AnisotropicFiltering>` **ANISOTROPY_MAX** = ``5``
Représente la taille de l’énumération :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``
Ne pas effectuer d'anticrénelage dans le post-traitement du plein écran.
.. _class_Viewport_constant_SCREEN_SPACE_AA_FXAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_FXAA** = ``1``
Utiliser un antialiasing approximatif rapide. La FXAA est une méthode populaire d'anti-crénelage de l'espace-écran, qui est rapide, mais rendra l'image floue, en particulier dans les basses résolutions. Elle peut toujours fonctionner relativement bien dans de grandes résolutions telles que 1440p et 4K.
.. _class_Viewport_constant_SCREEN_SPACE_AA_SMAA:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_SMAA** = ``2``
Utiliser l’anticrénelage morphologique sous-pixel. La SMAA peut produire des résultats plus clairs que la FXAA, mais à un coût de performance légèrement plus élevé.
.. _class_Viewport_constant_SCREEN_SPACE_AA_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`ScreenSpaceAA<enum_Viewport_ScreenSpaceAA>` **SCREEN_SPACE_AA_MAX** = ``3``
Représente la taille de l'énumération :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``
Quantité d’objets dans le cadre.
.. _class_Viewport_constant_RENDER_INFO_PRIMITIVES_IN_FRAME:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_PRIMITIVES_IN_FRAME** = ``1``
Quantité de sommets dans l'image.
.. _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``
Le nombre de draw calls à chaque trame.
.. _class_Viewport_constant_RENDER_INFO_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfo<enum_Viewport_RenderInfo>` **RENDER_INFO_MAX** = ``3``
Représente la taille de l'énumération :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``
Passe de rendu du visible (hors ombres).
.. _class_Viewport_constant_RENDER_INFO_TYPE_SHADOW:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_SHADOW** = ``1``
Passe de rendu des ombres. Les objets seront rendus plusieurs fois en fonction du nombre de lumières avec des ombres et du nombre de divisions des ombres directionnelles.
.. _class_Viewport_constant_RENDER_INFO_TYPE_CANVAS:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_CANVAS** = ``2``
Rendu des éléments de canevas. Cela inclut tous les rendus 2D.
.. _class_Viewport_constant_RENDER_INFO_TYPE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`RenderInfoType<enum_Viewport_RenderInfoType>` **RENDER_INFO_TYPE_MAX** = ``3``
Représente la taille de l'énumération :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``
Les objets sont affichés normalement.
.. _class_Viewport_constant_DEBUG_DRAW_UNSHADED:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_UNSHADED** = ``1``
Les objets sont affichés sans les informations de lumière.
.. _class_Viewport_constant_DEBUG_DRAW_LIGHTING:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_LIGHTING** = ``2``
Les objets sont affichés sans texture et seulement avec des informations d'éclairage.
\ **Note :** Lors de l'utilisation de ce mode de dessin de débogage, les shaders personnalisés sont ignorés puisque tous les matériaux de la scène utilisent temporairement un matériau de débogage. Cela signifie que le résultat des fonctions de shader personnalisés (comme le déplacement de sommets) ne sera plus visible lors de l'utilisation de ce mode de dessin de débogage.
.. _class_Viewport_constant_DEBUG_DRAW_OVERDRAW:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OVERDRAW** = ``3``
Les objets sont affichés en semi-transparent avec un mélange additif afin que vous puissiez voir où ils dessinent les uns sur les autres. Un sur-dessin plus élevé signifie que vous perdez des performances sur le dessin de pixels qui sont cachés derrière d'autres.
\ **Note :** Lors de l'utilisation de ce mode de dessin de débogage, les shaders personnalisés sont ignorés puisque tous les matériaux de la scène utilisent temporairement un matériau de débogage. Cela signifie que le résultat des fonctions de shader personnalisés (comme le déplacement de sommets) ne sera plus visible lors de l'utilisation de ce mode de dessin de débogage.
.. _class_Viewport_constant_DEBUG_DRAW_WIREFRAME:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_WIREFRAME** = ``4``
Les objets sont affichés en tant que modèles en fil de fer.
\ **Note :** :ref:`RenderingServer.set_debug_generate_wireframes()<class_RenderingServer_method_set_debug_generate_wireframes>` doit être appelée avant de charger tout maillage pour que les fils de fer soient visibles lors de l'utilisation de la méthode de rendu Compatibilité.
.. _class_Viewport_constant_DEBUG_DRAW_NORMAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_NORMAL_BUFFER** = ``5``
Les objets sont affichés sans information d'éclairage et leurs textures sont remplacées par du normal mapping.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu 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``
Les objets sont affichés avec seulement la valeur albédo des :ref:`VoxelGI<class_VoxelGI>`\ s. Nécessite au moins un nœud :ref:`VoxelGI<class_VoxelGI>` visible qui a été pré-calculé pour avoir un effet visible.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu 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``
Les objets sont affichés avec seulement la valeur d'éclairage des :ref:`VoxelGI<class_VoxelGI>`\ s. Nécessite au moins un nœud :ref:`VoxelGI<class_VoxelGI>` visible qui a été pré-calculé pour avoir un effet visible.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu 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``
Les objets sont affichés avec seulement la couleur d'émission des :ref:`VoxelGI<class_VoxelGI>`\ s. Nécessite au moins un nœud :ref:`VoxelGI<class_VoxelGI>` visible qui a été pré-calculé pour avoir un effet visible.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SHADOW_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SHADOW_ATLAS** = ``9``
Dessine l'atlas d'ombres qui stocke les ombres des :ref:`OmniLight3D<class_OmniLight3D>`\ s et des :ref:`SpotLight3D<class_SpotLight3D>`\ s dans le quadrant supérieur gauche du **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``
Dessine l'atlas des ombres qui stocke les ombres des :ref:`DirectionalLight3D<class_DirectionalLight3D>`\ s dans le quadrant supérieur gauche du **Viewport**.
.. _class_Viewport_constant_DEBUG_DRAW_SCENE_LUMINANCE:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SCENE_LUMINANCE** = ``11``
Dessine le buffer de luminance de la scène (si disponible) dans le quadrant supérieur gauche du **Viewport**.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SSAO:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSAO** = ``12``
Dessine la texture d'occlusion ambiante de l'espace-écran au lieu de la scène afin que vous puissiez voir clairement comment elle affecte les objets. Pour que ce mode d'affichage fonctionne, vous devez avoir :ref:`Environment.ssao_enabled<class_Environment_property_ssao_enabled>` défini dans votre :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SSIL:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SSIL** = ``13``
Dessine la texture d'éclairage indirect de l'espace-écran au lieu de la scène afin que vous puissiez voir clairement comment elle affecte les objets. Pour que ce mode d'affichage fonctionne, vous devez avoir :ref:`Environment.ssil_enabled<class_Environment_property_ssil_enabled>` défini dans votre :ref:`WorldEnvironment<class_WorldEnvironment>`.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_PSSM_SPLITS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_PSSM_SPLITS** = ``14``
Colorise chaque division PSSM pour les :ref:`DirectionalLight3D<class_DirectionalLight3D>`\ s dans la scène avec une couleur différente afin que vous puissiez voir où sont les divisions. Dans l'ordre (de la plus proche à la plus éloignée de la caméra), elles sont coloriées en rouge, vert, bleu et jaune.
\ **Note :** Lors de l'utilisation de ce mode de dessin de débogage, les shaders personnalisées sont ignorés puisque tous les matériaux de la scène utilisent temporairement un matériau de débogage. Cela signifie que le résultat des fonctions de shaders personnalisées (comme le déplacement de sommets) ne sera plus visible lors de l'utilisation de ce mode de dessin de débogage.
\ **Note :** Seulement supporté lors de l'utilisation des méthodes de rendu Forward+ ou Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_DECAL_ATLAS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DECAL_ATLAS** = ``15``
Draws the decal atlas used by :ref:`Decal<class_Decal>`\ s and light projector textures in the upper left quadrant of the **Viewport**.
\ **Note:** Only supported when using the Forward+ or Mobile rendering methods.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI** = ``16``
Dessine les cascades utilisées pour rendre l'illumination globale avec champ de distance signée (SDFGI).
Ne fait rien si le :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` de l'environnement actuel vaut ``false``.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_SDFGI_PROBES:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_SDFGI_PROBES** = ``17``
Dessine les sondes utilisées pour l'illumination globale avec champ de distance signée (SDFGI).
Ne fait rien si le :ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>` de l'environnement actuel vaut ``false``.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_GI_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_GI_BUFFER** = ``18``
Dessine le buffer utilisé pour l'illumination globale de :ref:`VoxelGI<class_VoxelGI>` ou de SDFGI. Nécessite que :ref:`VoxelGI<class_VoxelGI>` (au moins un nœud VoxelGI pré-calculé visible) ou que SDFGI (:ref:`Environment.sdfgi_enabled<class_Environment_property_sdfgi_enabled>`) soit activé pour avoir un effet visible.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_DISABLE_LOD:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_DISABLE_LOD** = ``19``
Dessine tous les objets à leur compte de polygones le plus haut indépendamment de leur distance de la caméra. Aucun niveau de détail faible (LOD) n'est appliqué.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_OMNI_LIGHTS** = ``20``
Dessine le cluster utilisé par les nœuds :ref:`OmniLight3D<class_OmniLight3D>` pour optimiser le rendu de la lumière.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu 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``
Dessine le cluster utilisé par les nœuds :ref:`SpotLight3D<class_SpotLight3D>` pour optimiser le rendu de la lumière.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_CLUSTER_DECALS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_CLUSTER_DECALS** = ``22``
Dessine le cluster utilisé par les nœuds :ref:`Decal<class_Decal>` pour optimiser le rendu des décalques.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu 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``
Dessine le cluster utilisé par les nœuds :ref:`ReflectionProbe<class_ReflectionProbe>` pour optimiser les sondes de réflexion.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_OCCLUDERS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_OCCLUDERS** = ``24``
Dessine le buffer utilisé pour l'occlusion culling.
\ **Note :** Seulement supporté lors de l'utilisation des méthodes de rendu Forward+ ou Mobile.
.. _class_Viewport_constant_DEBUG_DRAW_MOTION_VECTORS:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_MOTION_VECTORS** = ``25``
Dessine des lignes de vecteur sur le viewport pour indiquer le mouvement des pixels entre les trames.
\ **Note :** Seulement supporté lors de l'utilisation de la méthode de rendu Forward+.
.. _class_Viewport_constant_DEBUG_DRAW_INTERNAL_BUFFER:
.. rst-class:: classref-enumeration-constant
:ref:`DebugDraw<enum_Viewport_DebugDraw>` **DEBUG_DRAW_INTERNAL_BUFFER** = ``26``
Dessine le buffer de résolution interne de la scène dans l'espace de couleur linéaire avant que le tonemapping ou du post-traitement soit appliqué.
\ **Note :** Seulement supporté lors de l'utilisation des méthodes de rendu Forward+ ou 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``
Le filtrage de texture lit le pixel le plus proche seulement. Cela rend la texture pixelisée de loin, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).
.. _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``
Le filtrage de texture mélange les 4 pixels les plus proches. Cela rend la texture lisse de près, et granuleuse à une certaine distance (à cause des mipmaps qui ne sont pas échantillonnées).
.. _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``
Le filtrage de texture fusionne les 4 pixels les plus proches et les 2 mipmaps les plus proches (ou utilise la mipmap le plus proche si :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` est ``true``). Cela rend la texture lisse de près et lisse de loin.
Utilisez ce filtre pour les textures non pixel art susceptibles d'être visualisées à petite échelle (par exemple, grâce au zoom d'une :ref:`Camera2D<class_Camera2D>` ou à la mise à l'échelle du sprite), car les mipmaps sont importantes pour lisser les pixels plus petits que ceux à l'écran.
.. _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``
Le filtrage de texture lit à partir du pixel le plus proche et fusionne les deux mipmaps les plus proches (ou utilise la mipmap le plus proche si :ref:`ProjectSettings.rendering/textures/default_filters/use_nearest_mipmap_filter<class_ProjectSettings_property_rendering/textures/default_filters/use_nearest_mipmap_filter>` vaut ``true``). Cela donne à la texture un aspect pixelisé de près et lisse de loin.
Utilisez ce filtre pour les textures non pixel art susceptibles d'être visualisées à petite échelle (par exemple, à cause du zoom d'une :ref:`Camera2D<class_Camera2D>` ou à la mise à l'échelle des sprites), car les mipmaps sont importantes pour lisser les pixels qui sont plus petits que les pixels à l'écran.
.. _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``
Représente la taille de l’énumération :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``
Désactive la répétition des textures. À la place, lors de la lecture d'UVs en dehors de l'intervalle 0-1, la valeur sera bornée au bord de la texture, ce qui donne un aspect étiré sur les bordures de la texture.
.. _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``
Permet à la texture de se répéter lorsque les coordonnées UV sont à l'extérieur de l'intervalle 0-1. Si vous utilisez l'un des modes de filtrage linéaire, cela peut entraîner des artéfacts aux bords d'une texture lorsque l'échantillonneur filtre à travers les bords de la 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``
Inverse la texture lors de la répétition de sorte que les bords correspondent au lieu de changer brusquement.
.. _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``
Représente la taille de l’énumération :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``
Le champ de distance signée ne couvre que le propre rectangle du viewport.
.. _class_Viewport_constant_SDF_OVERSIZE_120_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_120_PERCENT** = ``1``
Le champ de distance signée est étendu pour couvrir 20% de la taille du viewport autour des bordures.
.. _class_Viewport_constant_SDF_OVERSIZE_150_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_150_PERCENT** = ``2``
Le champ de distance signée est étendu pour couvrir 50% de la taille du viewport autour des bordures.
.. _class_Viewport_constant_SDF_OVERSIZE_200_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_200_PERCENT** = ``3``
Le champ de distance signée est étendu pour couvrir 100% (le double) de la taille du viewport autour des bordures.
.. _class_Viewport_constant_SDF_OVERSIZE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFOversize<enum_Viewport_SDFOversize>` **SDF_OVERSIZE_MAX** = ``4``
Représente la taille de l'énumération :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``
Le champ de distance signée est rendu à pleine résolution.
.. _class_Viewport_constant_SDF_SCALE_50_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_50_PERCENT** = ``1``
Le champ de distance signée est rendu à la moitié de la résolution de ce viewport.
.. _class_Viewport_constant_SDF_SCALE_25_PERCENT:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_25_PERCENT** = ``2``
Le champ de distance signée est rendu au quart de la résolution de ce viewport.
.. _class_Viewport_constant_SDF_SCALE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`SDFScale<enum_Viewport_SDFScale>` **SDF_SCALE_MAX** = ``3``
Représente la taille de l'énumération :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``
Le Variable Rate Shading est désactivé.
.. _class_Viewport_constant_VRS_TEXTURE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_TEXTURE** = ``1``
Le Variable Rate Shading utilise une texture. Notez qu'en stéréoscopique, il faut utiliser un atlas de textures avec une texture pour chaque vue.
.. _class_Viewport_constant_VRS_XR:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_XR** = ``2``
La texture du Variable Rate Shading est fournie par la :ref:`XRInterface<class_XRInterface>` primaire.
.. _class_Viewport_constant_VRS_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSMode<enum_Viewport_VRSMode>` **VRS_MAX** = ``3``
Représente la taille de l'énumération :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 texture d'entrée pour le variable rate shading ne sera pas traitée.
.. _class_Viewport_constant_VRS_UPDATE_ONCE:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ONCE** = ``1``
La texture d'entrée pour le variable rate shading sera traitée une fois.
.. _class_Viewport_constant_VRS_UPDATE_ALWAYS:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_ALWAYS** = ``2``
La texture d'entrée pour le variable rate shading sera traitée à chaque trame.
.. _class_Viewport_constant_VRS_UPDATE_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>` **VRS_UPDATE_MAX** = ``3``
Représente la taille de l'énumération :ref:`VRSUpdateMode<enum_Viewport_VRSUpdateMode>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _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**\ (\ )
Définit le nombre maximal d'échantillons à prendre lors de l'utilisation du filtrage anisotrope sur des textures (en puissance de deux). Un nombre plus élevé d'échantillons résultera en des textures plus nettes à des angles obliques, mais est plus cher à calculer. Une valeur de ``0`` désactive de force le filtrage anisotrope, même sur les matériaux où il est activé.
Le niveau du filtrage anisotrope affecte aussi les décalques et les projecteurs de lumière s'ils sont configurés pour utiliser le filtrage anisotrope. Voir :ref:`ProjectSettings.rendering/textures/decals/filter<class_ProjectSettings_property_rendering/textures/decals/filter>` et :ref:`ProjectSettings.rendering/textures/light_projectors/filter<class_ProjectSettings_property_rendering/textures/light_projectors/filter>`.
\ **Note :** En 3D, pour que ce paramètre ait un effet, définissez :ref:`BaseMaterial3D.texture_filter<class_BaseMaterial3D_property_texture_filter>` à :ref:`BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` ou :ref:`BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_BaseMaterial3D_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` sur les matériaux.
\ **Note :** En 2D, pour que ce paramètre ait un effet, définissez :ref:`CanvasItem.texture_filter<class_CanvasItem_property_texture_filter>` à :ref:`CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC>` ou :ref:`CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC<class_CanvasItem_constant_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC>` sur le nœud :ref:`CanvasItem<class_CanvasItem>` affichant la texture (ou dans :ref:`CanvasTexture<class_CanvasTexture>`). Cependant, le filtrage anisotrope est rarement utile en 2D, donc ne l'activez pour des textures 2D que si cela fait une différence visuelle significative.
.. 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 ``true``, la fenêtre d'affichage gèrera les flux audio 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 ``true``, la fenêtre d'affichage gèrera les flux audio 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**\ (\ )
Les couches de rendu dans lesquelles ce **Viewport** rend des nœuds :ref:`CanvasItem<class_CanvasItem>`.
.. 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**\ (\ )
Définit le mode de filtrage par défaut utilisé par les :ref:`CanvasItem<class_CanvasItem>`\ s dans ce 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**\ (\ )
Définit le mode de répétition par défaut utilisé par les :ref:`CanvasItem<class_CanvasItem>`\ s dans ce 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 transformation du canevas de la fenpetre d'affichage, utile pour changer les positions à l'écran de tous les :ref:`CanvasItem<class_CanvasItem>` enfants. C'est relatif à la transformation globale du canevas de la fenêtre d'affichage.
.. 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**\ (\ )
Le mode de surcouche ("overlay") pour tester la géométrie rendue lors du débogage.
.. 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**\ (\ )
Désactive le rendu 3D (mais garde le rendu 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**\ (\ )
Détermine la netteté de l'image mise à l'échelle lors de l'utilisation du mode de mise à l'échelle FSR. La netteté est divisée par deux à chaque nombre entier. Les valeurs vont de 0.0 (le plus net) à 2.0. Les valeurs supérieures à 2,0 ne feront pas de différence visible.
Pour contrôler cette propriété sur le viewport racine, définissez le paramètre de projet :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 transformation globale de la toile de cette fenêtre d'affichage. La transformation en toile est relative à cela.
.. 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 ``true``, la fenêtre d'affichage ne recevra pas les événements d'entrée.
.. 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 ``true``, les sous-fenêtres (popups et boites de dialogue) seront intégrées dans la fenêtre de l'application d'une manière similaire à des nœuds Control. Si ``false``, ils apparaîtront comme des fenêtres séparées gérées par le système d'exploitation.
.. 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 ``true``, les contrôles de l'interface graphique dans la fenêtre d'affichage s'alignent au pixel près.
.. 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 ``true``, ce viewport marquera les événements d'entrée entrants gérés par lui-même. Si ``false``, cela est fait à la place par le premier viewport parent qui est défini pour gérer les entrées localement.
Un :ref:`SubViewportContainer<class_SubViewportContainer>` définira automatiquement cette propriété à ``false`` pour le **Viewport** contenu à l'intérieur.
Voir aussi :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` et :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**\ (\ )
Le biais de LOD automatique à utiliser pour les maillages rendus dans le **Viewport** (analogue à :ref:`ReflectionProbe.mesh_lod_threshold<class_ReflectionProbe_property_mesh_lod_threshold>`). Des valeurs plus élevées utiliseront des versions moins détaillées des maillages qui ont des variations de LOD générées. Si défini à ``0.0``, le LOD automatique est désactivé. Augmentez :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` pour améliorer les performances au coût des détails de géométrie.
Pour contrôler cette propriété sur le viewport racine, définissez le paramètre de projet :ref:`ProjectSettings.rendering/mesh_lod/lod_change/threshold_pixels<class_ProjectSettings_property_rendering/mesh_lod/lod_change/threshold_pixels>`.
\ **Note :** :ref:`mesh_lod_threshold<class_Viewport_property_mesh_lod_threshold>` n'affecte pas les plages de visibilité de :ref:`GeometryInstance3D<class_GeometryInstance3D>` (également appelées LOD "manuel" ou LOD hiérarchique).
.. 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**\ (\ )
Le mode d'anti-crénelage multi-échantillon pour le rendu 2D/Canevas. Un nombre plus élevé se traduit par des bords plus lisses au coût de performances nettement pires. Une valeur de :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` ou :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` est préférable à moins de cibler des systèmes très haut de gamme. Cela n'a aucun effet sur le crénelage du à des shaders ou le crénelage de texture.
Voir aussi :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_2d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_2d>` et :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**\ (\ )
Le mode d'anti-crénelage multi-échantillon pour le rendu 3D. Un nombre plus élevé se traduit par des bords plus lisses au coût de performances nettement pires. Une valeur de :ref:`MSAA_2X<class_Viewport_constant_MSAA_2X>` ou :ref:`MSAA_4X<class_Viewport_constant_MSAA_4X>` est préférable à moins de cibler des systèmes très haut de gamme. Voir aussi la mise à l'échelle bilinéaire 3D :ref:`scaling_3d_mode<class_Viewport_property_scaling_3d_mode>` pour du sur-échantillonnage, qui fournit une qualité supérieure mais est beaucoup plus cher. Cela n'a aucun effet sur le crénelage du à des shaders ou le crénelage de texture.
Voir aussi :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` et :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 ``true`` et que l'une des conditions suivantes est vraie : :ref:`SubViewport.size_2d_override_stretch<class_SubViewport_property_size_2d_override_stretch>` et :ref:`SubViewport.size_2d_override<class_SubViewport_property_size_2d_override>` sont définis, :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>` est activé et la mise à l'échelle est activée, :ref:`oversampling_override<class_Viewport_property_oversampling_override>` est activé, le sur-échantillonnage des polices et de :ref:`DPITexture<class_DPITexture>` est activé.
.. 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 supérieur à zéro, cette valeur est utilisée comme facteur de sur-échantillonnage de police, sinon le sur-échantillonnage est égal à l'échelle du 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 ``true``, le viewport utilisera une copie unique du :ref:`World3D<class_World3D>` défini dans la propriété :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 ``true``, les objets rendus par le viewport deviennent des sujets du processus de sélection par la souris.
\ **Note :** Le nombre d'objets pouvant être choisis simultanément est limité à 64 et ils sont sélectionnés dans un ordre non déterministe, qui peut être différent à chaque processus de sélection.
.. 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 ``true``, le signal input_event ne sera envoyé qu'à un objet physique dans le processus de sélection de la souris. Si vous voulez obtenir l'objet du haut seulement, vous devez également activer :ref:`physics_object_picking_sort<class_Viewport_property_physics_object_picking_sort>`.
Si ``false``, un signal input_event sera envoyé à tous les objets physiques dans le processus de sélection de la souris.
Ceci s'applique à la sélection d'objets CanvasItem 2D uniquement.
.. 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 ``true``, les objets reçoivent des événements de sélection de souris triés d'abord par leur :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` puis par leur position dans l'arborescence de scène. Si ``false``, l'ordre est indéterminé.
\ **Note :** Ce paramètre est désactivé par défaut en raison de son coût de calcul coûteux potentiel.
\ **Note :** Le tri s'effectue après avoir sélectionné les objets sélectionnables. En raison de la limitation de 64 objets récupérables simultanément, il n'est pas garanti que l'objet avec le plus haut :ref:`CanvasItem.z_index<class_CanvasItem_property_z_index>` reçoive l'événement de sélection.
.. 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 quantité de sous-division du premier quadrant de l'atlas de l'ombre.
.. 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 quantité de sous-division du deuxième quadrant de l'atlas de l'ombre.
.. 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 quantité de sous-division du troisième quadrant de l'atlas de l'ombre.
.. 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 quantité de sous-division du quatrième quadrant de l'atlas de l'ombre.
.. 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 résolution de l'atlas des ombres (utilisé pour les SpotLights et OmniLights). La valeur est arrondie à la puissance de 2 la plus proche.
\ **Note :** Si cela est défini à ``0``, aucune ombre positionnelle ne sera visible du tout. Cela peut améliorer considérablement les performances sur les systèmes bas de gamme en réduisant à la fois la charge CPU et GPU (car il faut moins de draw calls pour dessiner la scène sans ombres).
.. 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**\ (\ )
Définit le mode d'échelle 3D. L'échelle bilinéaire rend à une résolution différente pour soit sous-échantillonner soit sur-échantillonner le viewport. FidelityFX Super Resolution 1.0, abrégé en FSR, est une technologie de redimensionnement qui produit des images de haute qualité à des framerates rapides en utilisant un algorithme de redimensionnement spatialement conscient. Le FSR est légèrement plus cher que le bilinéaire, mais il produit une qualité d'image beaucoup plus élevée. Le FSR devrait être utilisé si possible.
Pour contrôler cette propriété sur le viewport racine, définissez le paramètre de projet :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**\ (\ )
Redimensionne le buffer de rendu 3D selon la taille du viewport en utilisant un filtrage d'image spécifié dans :ref:`ProjectSettings.rendering/scaling_3d/mode<class_ProjectSettings_property_rendering/scaling_3d/mode>` pour mettre à l'échelle l'image de sortie à la taille complète du viewport. Les valeurs inférieures à ``1.0`` peuvent être utilisées pour accélérer le rendu 3D au coût de la qualité (sous-échantillonnage). Les valeurs supérieures à ``1.0`` ne sont valables que pour le mode bilinéaire et peuvent être utilisées pour améliorer la qualité du rendu 3D à un coût élevé sur les performances (sur-échantillonnage). Voir aussi :ref:`ProjectSettings.rendering/anti_aliasing/quality/msaa_3d<class_ProjectSettings_property_rendering/anti_aliasing/quality/msaa_3d>` pour l'anti-crénelage multi-échantillons, qui est nettement moins cher mais ne lisse que les bords des polygones.
Lors de l'utilisation de l'upscaling FSR, AMD recommande d'indiquer les valeurs suivantes comme options prédéfinies aux utilisateurs "Qualité Ultra : 0.77", "Qualité : 0.67", "Équilibré : 0.59", "Performances : 0.5" au lieu d'exposer l'échelle entière.
Pour contrôler cette propriété sur le viewport racine, définissez le paramètre de projet :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**\ (\ )
Définit la méthode d'anti-crénelage de l'espace-écran utilisée. L'anti-crénelage de l'espace-écran fonctionne en sélectionnant des bords flous dans un shader de post-traitement. Il diffère de la MSAA qui prend plusieurs échantillons de couverture tout en rendant des objets. Les méthodes d'anti-crénelage de l'espace d'écran sont généralement plus rapides que la MSAA et lissent le crénelage spéculaire, mais ont tendance à rendre les scènes floues.
Voir aussi :ref:`ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa<class_ProjectSettings_property_rendering/anti_aliasing/quality/screen_space_aa>` et :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**\ (\ )
Controls how much of the original viewport's size should be covered by the 2D signed distance field. This SDF can be sampled in :ref:`CanvasItem<class_CanvasItem>` shaders and is also used for :ref:`GPUParticles2D<class_GPUParticles2D>` collision. Higher values allow portions of occluders located outside the viewport to still be taken into account in the generated signed distance field, at the cost of performance. If you notice particles falling through :ref:`LightOccluder2D<class_LightOccluder2D>`\ s as the occluders leave the viewport, increase this setting.
The percentage is added on each axis and on both sides. For example, with the default :ref:`SDF_OVERSIZE_120_PERCENT<class_Viewport_constant_SDF_OVERSIZE_120_PERCENT>`, the signed distance field will cover 20% of the viewport's size outside the viewport on each side (top, right, bottom, left).
.. 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**\ (\ )
L'échelle de résolution à utiliser pour le champ de distance signée 2D. Les valeurs plus élevées conduisent à un champ de distance signée plus précis et plus stable lorsque la caméra se déplace, avec un coût sur les performances.
.. 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 ``true``, les nœuds :ref:`CanvasItem<class_CanvasItem>` s’aimanteront en interne sur des pixels complets. Leur position peut encore être au sous-pixel, mais les décimales n'auront pas d'effet. Cela peut conduire à un aspect plus net au coût d'un mouvement moins lisse, surtout lorsque le lissage de la :ref:`Camera2D<class_Camera2D>` est activé.
.. 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 ``true``, les sommets des nœuds :ref:`CanvasItem<class_CanvasItem>` s’aimanteront sur des pixels complets. N'affecte que les positions finales des sommets, pas les transformations. Cela peut conduire à un aspect plus net au coût d'un mouvement moins lisse, surtout lorsque le lissage de la :ref:`Camera2D<class_Camera2D>` est activé.
.. 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**\ (\ )
Affects the final texture sharpness by reading from a lower or higher mipmap (also called "texture LOD bias"). Negative values make mipmapped textures sharper but grainier when viewed at a distance, while positive values make mipmapped textures blurrier (even when up close).
Enabling temporal antialiasing (:ref:`use_taa<class_Viewport_property_use_taa>`) will automatically apply a ``-0.5`` offset to this value, while enabling FXAA (:ref:`screen_space_aa<class_Viewport_property_screen_space_aa>`) will automatically apply a ``-0.25`` offset to this value. If both TAA and FXAA are enabled at the same time, an offset of ``-0.75`` is applied to this value.
\ **Note:** If :ref:`scaling_3d_scale<class_Viewport_property_scaling_3d_scale>` is lower than ``1.0`` (exclusive), :ref:`texture_mipmap_bias<class_Viewport_property_texture_mipmap_bias>` is used to adjust the automatic mipmap bias which is calculated internally based on the scale factor. The formula for this is ``log2(scaling_3d_scale) + mipmap_bias``.
To control this property on the root viewport, set the :ref:`ProjectSettings.rendering/textures/default_filters/texture_mipmap_bias<class_ProjectSettings_property_rendering/textures/default_filters/texture_mipmap_bias>` project setting.
.. 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**\ (\ )
If ``true``, uses a fast post-processing filter to make banding significantly less visible. 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.
In some cases, debanding may introduce a slightly noticeable dithering pattern. It's recommended to enable debanding only when actually needed since the dithering pattern will make lossless-compressed screenshots larger.
See also :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_debanding<class_ProjectSettings_property_rendering/anti_aliasing/quality/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) format framebuffer matching the bit depth of the 3D framebuffer. When using the Forward+ or Compatibility renderer, this will be an ``RGBA16`` framebuffer. When using the Mobile renderer, it will be an ``RGB10_A2`` framebuffer.
Additionally, 2D rendering will take place in linear color space and will be converted to sRGB space 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 space 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 ``true``, les nœuds :ref:`OccluderInstance3D<class_OccluderInstance3D>` seront utilisables pour l'occlusion culling en 3D pour ce viewport. Pour le viewport racine, :ref:`ProjectSettings.rendering/occlusion_culling/use_occlusion_culling<class_ProjectSettings_property_rendering/occlusion_culling/use_occlusion_culling>` doit être défini à ``true`` à la place.
\ **Note :** Activer l'occlusion culling a un coût sur le CPU. N'activer l'occlusion culling que si vous envisagez réellement de l'utiliser, et pensez si votre scène peut réellement bénéficier de l'occlusion culling. Les grandes scènes ouvertes avec peu ou pas d'objets bloquant la vue ne bénéficieront généralement pas beaucoup de l'occlusion culling. Les grandes scènes ouvertes profitent généralement davantage des plages de visibilité et des LODs de maillages (:ref:`GeometryInstance3D.visibility_range_begin<class_GeometryInstance3D_property_visibility_range_begin>` et :ref:`GeometryInstance3D.visibility_range_end<class_GeometryInstance3D_property_visibility_range_end>`) par rapport à l'occlusion culling.
\ **Note :** En raison des contraintes de mémoire, l'occlusion culling n'est pas supporté par défaut dans les modèles d'export Web. Elle peut être activée en compilant des modèles d'export Web personnalisés avec ``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**\ (\ )
Enables temporal antialiasing for this viewport. TAA works by jittering the camera and accumulating the images of the last rendered frames, motion vector rendering is used to account for camera and object motion.
\ **Note:** The implementation is not complete yet, some visual instances such as particles and skinned meshes may show artifacts.
See also :ref:`ProjectSettings.rendering/anti_aliasing/quality/use_taa<class_ProjectSettings_property_rendering/anti_aliasing/quality/use_taa>` and :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 ``true``, le viewport utilisera l'interface primaire XR pour rendre la sortie XR. Le cas échéant, cela peut résulter en une image stéréoscopique et l'envoi du rendu résultant vers un casque.
.. 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**\ (\ )
Le mode Variable Rate Shading (VRS) qui est utilisé pour ce viewport. Notez, si du matériel ne supporte pas le VRS, cette propriété est ignorée.
.. 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**\ (\ )
Texture à utiliser lorsque :ref:`vrs_mode<class_Viewport_property_vrs_mode>` est défini à :ref:`VRS_TEXTURE<class_Viewport_constant_VRS_TEXTURE>`.
La texture *doit* utiliser un format de compression sans perte afin que les couleurs puissent être associées avec précision. Les densités VRS suivantes sont associées à différentes couleurs, avec les couleurs plus vives représentant un niveau inférieur de précision du shader :
.. 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 - Non supporté sur la plupart des matériels
- 8×4 = rgb(255, 170, 0) - #ffaa00 - Non supporté sur la plupart des matériels
- 8×8 = rgb(255, 255, 0) - #ffff00 - Non supporté sur la plupart des matériels
.. 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**\ (\ )
Définit le mode de mise à jour pour le Variable Rate Shading (VRS) pour le viewport. Le VRS exige que la texture d'entrée soit convertie au format utilisable par la méthode VRS supportée par le matériel. Le mode de mise à jour définit combien de fois cela se produit. Si le GPU ne supporte pas le VRS, ou si le VRS n'est pas activé, cette propriété est ignorée.
.. 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**\ (\ )
Le :ref:`World3D<class_World3D>` personnalisé qui peut être utilisé comme source pour l'environnement 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**\ (\ )
Le :ref:`World3D<class_World3D>` personnalisé qui peut être utilisé comme source d'environnement 3D.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _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>`
Renvoie le premier :ref:`World2D<class_World2D>` valide de ce viewport, en cherchant dans sa propriété :ref:`world_2d<class_Viewport_property_world_2d>` ainsi que celle de ses parents 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>`
Renvoie le premier :ref:`World3D<class_World3D>` valide de ce viewport, en cherchant dans sa propriété :ref:`world_3d<class_Viewport_property_world_3d>` ainsi que celles de ses ancêtres 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>`
Renvoie l'auditeur audio 2D actuellement actif. Renvoie ``null`` s'il n'y a pas d'auditeurs audio 2D actifs, auquel cas la caméra 2D active sera traitée comme auditeur.
.. 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>`
Renvoie l'auditeur audio 3D actuellement actif. Renvoie ``null`` s'il n'y a pas d'auditeurs audio 3D actifs, auquel cas la caméra 3D active sera traitée comme auditeur.
.. 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>`
Renvoie la caméra 2D actuellement active. Renvoie ``null`` s'il n'y a pas de caméra active.
.. 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>`
Renvoie la caméra 3D actuellement active.
.. 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>`
Renvoie un bit individuel sur le masque des couches de rendu.
.. 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>`
Renvoie une liste des :ref:`Window<class_Window>`\ s intégrées visibles à l'intérieur du viewport.
\ **Note :** Les :ref:`Window<class_Window>`\ s à l'intérieur d'autres viewports ne seront pas listées.
.. 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>`
Renvoie la transformation du système de coordonnées du viewport vers le système de coordonnées de l'intégrateur.
.. 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>`
Renvoie la position de la souris dans ce **Viewport** en utilisant le système de coordonnées de ce **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>`
Renvoie le facteur de suréchantillonnage du 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>`
Returns the positional shadow atlas quadrant subdivision of the specified quadrant.
.. 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>`
Renvoie des statistiques de rendu du type donné.
.. 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>`
Returns the transform from the Viewport's coordinates to the screen coordinates of the containing window manager window.
.. 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>`
Renvoie la transformation d'étirement 2D automatiquement calculée, en tenant compte des réglages d'étirement du **Viewport**. La valeur finale est multipliée par :ref:`Window.content_scale_factor<class_Window_property_content_scale_factor>`, mais seulement pour le viewport racine. Si cette méthode est appelée sur un :ref:`SubViewport<class_SubViewport>` (par exemple, dans un arborescence de scène avec :ref:`SubViewportContainer<class_SubViewportContainer>` et :ref:`SubViewport<class_SubViewport>`), le facteur d'échelle du viewport racine ne sera pas appliqué. En utilisant :ref:`Transform2D.get_scale()<class_Transform2D_method_get_scale>` sur la valeur renvoyée, cela peut être utilisé pour compenser l'échelle lors du zoom d'un nœud :ref:`Camera2D<class_Camera2D>`, ou pour rétrécir un :ref:`TextureRect<class_TextureRect>` pour être au pixel près indépendamment du facteur d'échelle calculé automatiquement.
\ **Note :** En raison de la façon dont fonctionne l'échelle des pixels, l'échelle en X et en Y de la transformation renvoyée peut différer légèrement, même lorsque :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` est définie à un mode qui conserve le rapport d'aspect des pixels. Si :ref:`Window.content_scale_aspect<class_Window_property_content_scale_aspect>` vaut :ref:`Window.CONTENT_SCALE_ASPECT_IGNORE<class_Window_constant_CONTENT_SCALE_ASPECT_IGNORE>`, l'échelle en X et en Y peut différer *de façon significative*.
.. 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>`
Renvoie la texture du viewport.
\ **Note :** Lorsque vous essayez de stocker la texture actuelle (par exemple dans un fichier), elle peut être complètement noire ou périmée si elle est utilisée trop tôt, surtout lorsqu'elle est utilisée par ex. dans :ref:`Node._ready()<class_Node_private_method__ready>`. Pour vous assurer que la texture que vous obtenez est correcte, vous pouvez attendre le signal :ref:`RenderingServer.frame_post_draw<class_RenderingServer_signal_frame_post_draw>`.
.. tabs::
.. code-tab:: gdscript
func _ready():
await RenderingServer.frame_post_draw
$Viewport.get_texture().get_image().save_png("user://Capture_d_ecran.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://Capture_d_ecran.png");
}
\ **Note :** Lorsque :ref:`use_hdr_2d<class_Viewport_property_use_hdr_2d>` vaut ``true``, la texture renvoyée sera une image HDR encodée dans l'espace linéaire.
.. 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>`
Renvoie le RID du viewport depuis le :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>`
Renvoie le rectangle de visibilité à l'écran dans les coordonnées globales.
.. 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>`
Annule l'opération de glissement qui a déjà été lancée par :ref:`Control._get_drag_data()<class_Control_private_method__get_drag_data>` ou forcée avec :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>`
Renvoie les données de déposer-glisser du GUI, qui étaient précédemment renvoyées par :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 drag data human-readable description.
.. 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>`
Renvoie le :ref:`Control<class_Control>` ayant actuellement le focus dans ce viewport. Si aucun :ref:`Control<class_Control>` n'a le focus, renvoie ``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>`
Renvoie le :ref:`Control<class_Control>` que la souris survole dans ce viewport. Si aucun :ref:`Control<class_Control>` n'a le curseur, renvoie ``null``.
Typiquement le nœud :ref:`Control<class_Control>` feuille ou le niveau le plus profond du sous-arbre qui revendique le survol. Ceci est très utile lorsqu'utilisé avec :ref:`Node.is_ancestor_of()<class_Node_method_is_ancestor_of>` pour trouver si la souris est dans un arbre de contrôles.
.. 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>`
Renvoie ``true`` si l'opération de glisser-déposer a réussi.
.. 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>`
Renvoie ``true`` si une opération de glissement est en cours et où l'action de déposer pourrait se produire dans ce viewport.
Alternative à :ref:`Node.NOTIFICATION_DRAG_BEGIN<class_Node_constant_NOTIFICATION_DRAG_BEGIN>` et :ref:`Node.NOTIFICATION_DRAG_END<class_Node_constant_NOTIFICATION_DRAG_END>` lorsque vous préférez sonder la valeur.
.. 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>`
Retire le focus du :ref:`Control<class_Control>` ayant actuellement le focus dans ce viewport. Si aucun :ref:`Control<class_Control>` n'a le focus, ne fait rien.
.. 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>`
Définit la description facilement lisible des données de glissement.
.. 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>`
Renvoie si l':ref:`InputEvent<class_InputEvent>` actuel a été géré. Les événements d'entrée ne sont pas gérés jusqu'à ce que :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>` ait été appelée pendant la durée de vie d'un :ref:`InputEvent<class_InputEvent>`.
Ceci est généralement fait dans le cadre de méthodes de manipulation des entrées comme :ref:`Node._input()<class_Node_private_method__input>`, :ref:`Control._gui_input()<class_Control_private_method__gui_input>` ou d'autres, ainsi que dans les gestionnaires des signaux correspondants.
Si :ref:`handle_input_locally<class_Viewport_property_handle_input_locally>` est défini à ``false``, cette méthode va essayer de trouver le premier viewport parent qui est défini pour gérer l'entrée localement, et de renvoyer sa valeur pour :ref:`is_input_handled()<class_Viewport_method_is_input_handled>` à la place.
.. 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>`
Informe le Viewport que la souris est entrée dans sa zone. Utilisez cette fonction avant d'envoyer un :ref:`InputEventMouseButton<class_InputEventMouseButton>` ou un :ref:`InputEventMouseMotion<class_InputEventMouseMotion>` au **Viewport** avec :ref:`push_input()<class_Viewport_method_push_input>`. Voir aussi :ref:`notify_mouse_exited()<class_Viewport_method_notify_mouse_exited>`.
\ **Note :** Dans la plupart des cas, il n'est pas nécessaire d'appeler cette fonction parce que les nœuds :ref:`SubViewport<class_SubViewport>` qui sont des enfants de :ref:`SubViewportContainer<class_SubViewportContainer>` sont notifiés automatiquement. Cela n'est nécessaire que lorsqu'on interagit avec des viewports de façon non par défaut, par exemple comme des textures dans :ref:`TextureRect<class_TextureRect>` ou avec une :ref:`Area3D<class_Area3D>` qui transmet les événements d'entrée.
.. 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>`
Informe le Viewport que la souris a quitté sa zone. Utilisez cette fonction lorsque le nœud qui affiche le viewport note que la souris a quitté la zone du viewport affiché. Voir aussi :ref:`notify_mouse_entered()<class_Viewport_method_notify_mouse_entered>`.
\ **Note :** Dans la plupart des cas, il n'est pas nécessaire d'appeler cette fonction parce que les nœuds :ref:`SubViewport<class_SubViewport>` qui sont des enfants de :ref:`SubViewportContainer<class_SubViewportContainer>` sont notifiés automatiquement. Cela n'est nécessaire que lorsqu'on interagit avec des viewports de façon non par défaut, par exemple comme des textures dans :ref:`TextureRect<class_TextureRect>` ou avec une :ref:`Area3D<class_Area3D>` qui transmet les événements d'entrée.
.. 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>`
Déclenche l'évènement ``event`` donné dans ce **Viewport**. Cela peut être utilisé pour passer un :ref:`InputEvent<class_InputEvent>` entre des viewports, ou pour appliquer localement des entrées qui ont été envoyées sur le réseau ou sauvegardées dans un fichier.
Si ``in_local_coords`` vaut ``false``, la position de l'événement est dans les coordonnées de l'éditeur et sera convertie en coordonnées du viewport. Si ``in_local_coords`` vaut ``true``, la position de l'événement est dans les coordonnées du viewport.
Bien que cette méthode serve un but similaire à :ref:`Input.parse_input_event()<class_Input_method_parse_input_event>`, elle ne ré-associe pas l'``event`` spécifié selon les paramètres du projet comme :ref:`ProjectSettings.input_devices/pointing/emulate_touch_from_mouse<class_ProjectSettings_property_input_devices/pointing/emulate_touch_from_mouse>`.
L'appel de cette méthode va propager des appels aux nœuds enfants pour les méthodes suivantes dans l'ordre donné :
- :ref:`Node._input()<class_Node_private_method__input>`\
- :ref:`Control._gui_input()<class_Control_private_method__gui_input>` pour les nœuds :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 une méthode antérieure marque l'entrée comme gérée via :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, toute méthode ultérieure dans cette liste ne sera pas appelée.
Si aucune des méthodes ne gèrent l'événement et que :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` vaut ``true``, l'événement est utilisé pour la sélection d'objets physiques.
.. 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éthode d'aide qui appelle la méthode ``set_text()`` sur le :ref:`Control<class_Control>` ayant actuellement le focus, à condition qu'elle soit définie (par ex. si le Control ciblé est un :ref:`Button<class_Button>` ou un :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>`
**Obsolète :** Use :ref:`push_input()<class_Viewport_method_push_input>` instead.
Déclenche l'évènement ``event`` donné dans ce **Viewport**. Cela peut être utilisé pour passer un :ref:`InputEvent<class_InputEvent>` entre des viewports, ou pour appliquer localement des entrées qui ont été envoyées sur le réseau ou sauvegardées dans un fichier.
Si ``in_local_coords`` vaut ``false``, la position de l'événement est dans les coordonnées de l'intégrateur et sera convertie en coordonnées du viewport. Si ``in_local_coords`` vaut ``true``, la position de l'événement est dans les coordonnées du viewport.
L'appel de cette méthode va propager des appels aux nœuds enfants pour les méthodes suivantes dans l'ordre donné :
- :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 une méthode antérieure marque l'entrée comme gérée via :ref:`set_input_as_handled()<class_Viewport_method_set_input_as_handled>`, toute méthode ultérieure dans cette liste ne sera pas appelée.
Si aucune des méthodes ne gèrent l'événement et que :ref:`physics_object_picking<class_Viewport_property_physics_object_picking>` vaut ``true``, l'événement est utilisé pour la sélection d'objets physiques.
\ **Note :** Cette méthode ne propage pas d'événements d'entrée aux :ref:`Window<class_Window>`\ s ou :ref:`SubViewport<class_SubViewport>`\ s intégrés.
.. 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>`
Définit ou efface des bits individuels sur le masque de couches de rendu. Cela simplifie l'édition des couches de ce **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>`
Empêche l'entrée de se propager plus profondément dans le :ref:`SceneTree<class_SceneTree>`.
\ **Note :** Cela n'affecte pas les méthodes dans :ref:`Input<class_Input>`, seulement la façon dont les événements sont propagés.
.. 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>`
Définit le nombre de sous-divisions à utiliser dans le quadrant spécifié. Un nombre plus élevé de sous-divisions vous permet d'avoir plus d'ombres dans la scène à la fois, mais réduit la qualité des ombres. Une bonne habitude est d'avoir des quadrants avec un nombre variable de sous-divisions et d'avoir peu de sous-divisions autant que possible.
.. 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>`
Force la mise à jour instantanée de l'écran en fonction de la position actuelle du curseur de la souris. Cela comprend la mise à jour de la forme du curseur de la souris et l'envoi des signaux nécessaires :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>` et :ref:`Window.mouse_entered<class_Window_signal_mouse_entered>` et leurs homologues respectifs ``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>`
Déplace le pointeur de la souris à la position spécifiée dans ce **Viewport** en utilisant le système de coordonnées de ce **Viewport**.
\ **Note :** :ref:`warp_mouse()<class_Viewport_method_warp_mouse>` n'est supportée que sous Windows, macOS et Linux. Elle n'a aucun effet sur Android, iOS et Web.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink