godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/class_navigationserver3d.rst
Rémi Verschelde b20bcbb88b Sync classref with 4.5 branch
2025-09-30 13:31:55 +02:00

2412 lines
212 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_NavigationServer3D:
NavigationServer3D
==================
**Sperimentale:** This class may be changed or removed in future versions.
**Eredita:** :ref:`Object<class_Object>`
Un'interfaccia server per l'accesso di basso livello alla navigazione 3D.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
NavigationServer3D è il server che gestisce le mappe di navigazione, le regioni e gli agenti. Non gestisce la navigazione A\* da :ref:`AStar3D<class_AStar3D>`.
Le mappe sono divise in regioni, composte da poligoni di navigazione. Insieme, definiscono le aree attraversabili nel mondo 3D.
\ **Nota:** La maggior parte delle modifiche nel **NavigationServer3D** ha effetto dopo il frame di fisica successivo e non immediatamente. Ciò include tutte le modifiche apportate a mappe, regioni o agenti da nodi nell'albero di scene che riguardano la navigazione, oppure tramite script.
Affinché due regioni siano collegate tra loro, devono condividere un bordo simile. Un bordo è considerato collegato a un altro se entrambi i suoi due vertici sono a una distanza inferiore a ``edge_connection_margin`` dal vertice dell'altro bordo rispettivo.
Puoi assegnare strati di navigazione alle regioni con :ref:`region_set_navigation_layers()<class_NavigationServer3D_method_region_set_navigation_layers>`, che possono poi essere controllati quando si richiede un percorso con :ref:`map_get_path()<class_NavigationServer3D_method_map_get_path>`. Questo può essere usato per consentire o vietare determinate aree per alcuni oggetti.
Per usare il sistema di evasione delle collisioni, puoi usare gli agenti. Puoi impostare la velocità di destinazione di un agente, quindi i server emetteranno un callback con una velocità modificata.
\ **Nota:** Il sistema di evasione delle collisioni ignora le regioni. L'uso diretto della velocità modificata potrebbe spostare un agente al di fuori dell'area attraversabile. Questa è una limitazione del sistema di evasione delle collisioni, qualsiasi situazione più complessa potrebbe richiedere l'uso del motore di fisica.
Questo server tiene traccia di qualsiasi chiamata e la esegue durante la fase di sincronizzazione. Ciò significa che è possibile richiedere qualsiasi modifica alla mappa, usando qualsiasi thread, senza preoccupazioni.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Utilizzo del NavigationServer <../tutorials/navigation/navigation_using_navigationservers>`
- `Demo di Navigazione 3D <https://godotengine.org/asset-library/asset/2743>`__
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`agent_create<class_NavigationServer3D_method_agent_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_get_avoidance_enabled<class_NavigationServer3D_method_agent_get_avoidance_enabled>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_avoidance_layers<class_NavigationServer3D_method_agent_get_avoidance_layers>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_avoidance_mask<class_NavigationServer3D_method_agent_get_avoidance_mask>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_avoidance_priority<class_NavigationServer3D_method_agent_get_avoidance_priority>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_height<class_NavigationServer3D_method_agent_get_height>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`agent_get_map<class_NavigationServer3D_method_agent_get_map>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`agent_get_max_neighbors<class_NavigationServer3D_method_agent_get_max_neighbors>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_max_speed<class_NavigationServer3D_method_agent_get_max_speed>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_neighbor_distance<class_NavigationServer3D_method_agent_get_neighbor_distance>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_get_paused<class_NavigationServer3D_method_agent_get_paused>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`agent_get_position<class_NavigationServer3D_method_agent_get_position>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_radius<class_NavigationServer3D_method_agent_get_radius>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_time_horizon_agents<class_NavigationServer3D_method_agent_get_time_horizon_agents>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`agent_get_time_horizon_obstacles<class_NavigationServer3D_method_agent_get_time_horizon_obstacles>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_get_use_3d_avoidance<class_NavigationServer3D_method_agent_get_use_3d_avoidance>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`agent_get_velocity<class_NavigationServer3D_method_agent_get_velocity>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_has_avoidance_callback<class_NavigationServer3D_method_agent_has_avoidance_callback>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`agent_is_map_changed<class_NavigationServer3D_method_agent_is_map_changed>`\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_callback<class_NavigationServer3D_method_agent_set_avoidance_callback>`\ (\ agent\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_enabled<class_NavigationServer3D_method_agent_set_avoidance_enabled>`\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_layers<class_NavigationServer3D_method_agent_set_avoidance_layers>`\ (\ agent\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_mask<class_NavigationServer3D_method_agent_set_avoidance_mask>`\ (\ agent\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_avoidance_priority<class_NavigationServer3D_method_agent_set_avoidance_priority>`\ (\ agent\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_height<class_NavigationServer3D_method_agent_set_height>`\ (\ agent\: :ref:`RID<class_RID>`, height\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_map<class_NavigationServer3D_method_agent_set_map>`\ (\ agent\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_max_neighbors<class_NavigationServer3D_method_agent_set_max_neighbors>`\ (\ agent\: :ref:`RID<class_RID>`, count\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_max_speed<class_NavigationServer3D_method_agent_set_max_speed>`\ (\ agent\: :ref:`RID<class_RID>`, max_speed\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_neighbor_distance<class_NavigationServer3D_method_agent_set_neighbor_distance>`\ (\ agent\: :ref:`RID<class_RID>`, distance\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_paused<class_NavigationServer3D_method_agent_set_paused>`\ (\ agent\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_position<class_NavigationServer3D_method_agent_set_position>`\ (\ agent\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_radius<class_NavigationServer3D_method_agent_set_radius>`\ (\ agent\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_time_horizon_agents<class_NavigationServer3D_method_agent_set_time_horizon_agents>`\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_time_horizon_obstacles<class_NavigationServer3D_method_agent_set_time_horizon_obstacles>`\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_use_3d_avoidance<class_NavigationServer3D_method_agent_set_use_3d_avoidance>`\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_velocity<class_NavigationServer3D_method_agent_set_velocity>`\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`agent_set_velocity_forced<class_NavigationServer3D_method_agent_set_velocity_forced>`\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bake_from_source_geometry_data<class_NavigationServer3D_method_bake_from_source_geometry_data>`\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bake_from_source_geometry_data_async<class_NavigationServer3D_method_bake_from_source_geometry_data_async>`\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`free_rid<class_NavigationServer3D_method_free_rid>`\ (\ rid\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`get_debug_enabled<class_NavigationServer3D_method_get_debug_enabled>`\ (\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`get_maps<class_NavigationServer3D_method_get_maps>`\ (\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_process_info<class_NavigationServer3D_method_get_process_info>`\ (\ process_info\: :ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_baking_navigation_mesh<class_NavigationServer3D_method_is_baking_navigation_mesh>`\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`link_create<class_NavigationServer3D_method_link_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`link_get_enabled<class_NavigationServer3D_method_link_get_enabled>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`link_get_end_position<class_NavigationServer3D_method_link_get_end_position>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`link_get_enter_cost<class_NavigationServer3D_method_link_get_enter_cost>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_iteration_id<class_NavigationServer3D_method_link_get_iteration_id>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`link_get_map<class_NavigationServer3D_method_link_get_map>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_navigation_layers<class_NavigationServer3D_method_link_get_navigation_layers>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`link_get_owner_id<class_NavigationServer3D_method_link_get_owner_id>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`link_get_start_position<class_NavigationServer3D_method_link_get_start_position>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`link_get_travel_cost<class_NavigationServer3D_method_link_get_travel_cost>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`link_is_bidirectional<class_NavigationServer3D_method_link_is_bidirectional>`\ (\ link\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_bidirectional<class_NavigationServer3D_method_link_set_bidirectional>`\ (\ link\: :ref:`RID<class_RID>`, bidirectional\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_enabled<class_NavigationServer3D_method_link_set_enabled>`\ (\ link\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_end_position<class_NavigationServer3D_method_link_set_end_position>`\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_enter_cost<class_NavigationServer3D_method_link_set_enter_cost>`\ (\ link\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_map<class_NavigationServer3D_method_link_set_map>`\ (\ link\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_navigation_layers<class_NavigationServer3D_method_link_set_navigation_layers>`\ (\ link\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_owner_id<class_NavigationServer3D_method_link_set_owner_id>`\ (\ link\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_start_position<class_NavigationServer3D_method_link_set_start_position>`\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`link_set_travel_cost<class_NavigationServer3D_method_link_set_travel_cost>`\ (\ link\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`map_create<class_NavigationServer3D_method_map_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_force_update<class_NavigationServer3D_method_map_force_update>`\ (\ map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_agents<class_NavigationServer3D_method_map_get_agents>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_cell_height<class_NavigationServer3D_method_map_get_cell_height>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_cell_size<class_NavigationServer3D_method_map_get_cell_size>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_get_closest_point<class_NavigationServer3D_method_map_get_closest_point>`\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_get_closest_point_normal<class_NavigationServer3D_method_map_get_closest_point_normal>`\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`map_get_closest_point_owner<class_NavigationServer3D_method_map_get_closest_point_owner>`\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_get_closest_point_to_segment<class_NavigationServer3D_method_map_get_closest_point_to_segment>`\ (\ map\: :ref:`RID<class_RID>`, start\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, use_collision\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_edge_connection_margin<class_NavigationServer3D_method_map_get_edge_connection_margin>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`map_get_iteration_id<class_NavigationServer3D_method_map_get_iteration_id>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_link_connection_radius<class_NavigationServer3D_method_map_get_link_connection_radius>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_links<class_NavigationServer3D_method_map_get_links>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`map_get_merge_rasterizer_cell_scale<class_NavigationServer3D_method_map_get_merge_rasterizer_cell_scale>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_obstacles<class_NavigationServer3D_method_map_get_obstacles>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`map_get_path<class_NavigationServer3D_method_map_get_path>`\ (\ map\: :ref:`RID<class_RID>`, origin\: :ref:`Vector3<class_Vector3>`, destination\: :ref:`Vector3<class_Vector3>`, optimize\: :ref:`bool<class_bool>`, navigation_layers\: :ref:`int<class_int>` = 1\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_get_random_point<class_NavigationServer3D_method_map_get_random_point>`\ (\ map\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] | :ref:`map_get_regions<class_NavigationServer3D_method_map_get_regions>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`map_get_up<class_NavigationServer3D_method_map_get_up>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_get_use_async_iterations<class_NavigationServer3D_method_map_get_use_async_iterations>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_get_use_edge_connections<class_NavigationServer3D_method_map_get_use_edge_connections>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`map_is_active<class_NavigationServer3D_method_map_is_active>`\ (\ map\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_active<class_NavigationServer3D_method_map_set_active>`\ (\ map\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_cell_height<class_NavigationServer3D_method_map_set_cell_height>`\ (\ map\: :ref:`RID<class_RID>`, cell_height\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_cell_size<class_NavigationServer3D_method_map_set_cell_size>`\ (\ map\: :ref:`RID<class_RID>`, cell_size\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_edge_connection_margin<class_NavigationServer3D_method_map_set_edge_connection_margin>`\ (\ map\: :ref:`RID<class_RID>`, margin\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_link_connection_radius<class_NavigationServer3D_method_map_set_link_connection_radius>`\ (\ map\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_merge_rasterizer_cell_scale<class_NavigationServer3D_method_map_set_merge_rasterizer_cell_scale>`\ (\ map\: :ref:`RID<class_RID>`, scale\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_up<class_NavigationServer3D_method_map_set_up>`\ (\ map\: :ref:`RID<class_RID>`, up\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_use_async_iterations<class_NavigationServer3D_method_map_set_use_async_iterations>`\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`map_set_use_edge_connections<class_NavigationServer3D_method_map_set_use_edge_connections>`\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`obstacle_create<class_NavigationServer3D_method_obstacle_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`obstacle_get_avoidance_enabled<class_NavigationServer3D_method_obstacle_get_avoidance_enabled>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`obstacle_get_avoidance_layers<class_NavigationServer3D_method_obstacle_get_avoidance_layers>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`obstacle_get_height<class_NavigationServer3D_method_obstacle_get_height>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`obstacle_get_map<class_NavigationServer3D_method_obstacle_get_map>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`obstacle_get_paused<class_NavigationServer3D_method_obstacle_get_paused>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`obstacle_get_position<class_NavigationServer3D_method_obstacle_get_position>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`obstacle_get_radius<class_NavigationServer3D_method_obstacle_get_radius>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`obstacle_get_use_3d_avoidance<class_NavigationServer3D_method_obstacle_get_use_3d_avoidance>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`obstacle_get_velocity<class_NavigationServer3D_method_obstacle_get_velocity>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`obstacle_get_vertices<class_NavigationServer3D_method_obstacle_get_vertices>`\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_avoidance_enabled<class_NavigationServer3D_method_obstacle_set_avoidance_enabled>`\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_avoidance_layers<class_NavigationServer3D_method_obstacle_set_avoidance_layers>`\ (\ obstacle\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_height<class_NavigationServer3D_method_obstacle_set_height>`\ (\ obstacle\: :ref:`RID<class_RID>`, height\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_map<class_NavigationServer3D_method_obstacle_set_map>`\ (\ obstacle\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_paused<class_NavigationServer3D_method_obstacle_set_paused>`\ (\ obstacle\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_position<class_NavigationServer3D_method_obstacle_set_position>`\ (\ obstacle\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_radius<class_NavigationServer3D_method_obstacle_set_radius>`\ (\ obstacle\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_use_3d_avoidance<class_NavigationServer3D_method_obstacle_set_use_3d_avoidance>`\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_velocity<class_NavigationServer3D_method_obstacle_set_velocity>`\ (\ obstacle\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`obstacle_set_vertices<class_NavigationServer3D_method_obstacle_set_vertices>`\ (\ obstacle\: :ref:`RID<class_RID>`, vertices\: :ref:`PackedVector3Array<class_PackedVector3Array>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`parse_source_geometry_data<class_NavigationServer3D_method_parse_source_geometry_data>`\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, root_node\: :ref:`Node<class_Node>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`query_path<class_NavigationServer3D_method_query_path>`\ (\ parameters\: :ref:`NavigationPathQueryParameters3D<class_NavigationPathQueryParameters3D>`, result\: :ref:`NavigationPathQueryResult3D<class_NavigationPathQueryResult3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_bake_navigation_mesh<class_NavigationServer3D_method_region_bake_navigation_mesh>`\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, root_node\: :ref:`Node<class_Node>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`region_create<class_NavigationServer3D_method_region_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AABB<class_AABB>` | :ref:`region_get_bounds<class_NavigationServer3D_method_region_get_bounds>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_closest_point<class_NavigationServer3D_method_region_get_closest_point>`\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_closest_point_normal<class_NavigationServer3D_method_region_get_closest_point_normal>`\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_closest_point_to_segment<class_NavigationServer3D_method_region_get_closest_point_to_segment>`\ (\ region\: :ref:`RID<class_RID>`, start\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, use_collision\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_connection_pathway_end<class_NavigationServer3D_method_region_get_connection_pathway_end>`\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_connection_pathway_start<class_NavigationServer3D_method_region_get_connection_pathway_start>`\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_connections_count<class_NavigationServer3D_method_region_get_connections_count>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_enabled<class_NavigationServer3D_method_region_get_enabled>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`region_get_enter_cost<class_NavigationServer3D_method_region_get_enter_cost>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_iteration_id<class_NavigationServer3D_method_region_get_iteration_id>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`region_get_map<class_NavigationServer3D_method_region_get_map>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_navigation_layers<class_NavigationServer3D_method_region_get_navigation_layers>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`region_get_owner_id<class_NavigationServer3D_method_region_get_owner_id>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`region_get_random_point<class_NavigationServer3D_method_region_get_random_point>`\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Transform3D<class_Transform3D>` | :ref:`region_get_transform<class_NavigationServer3D_method_region_get_transform>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`region_get_travel_cost<class_NavigationServer3D_method_region_get_travel_cost>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_use_async_iterations<class_NavigationServer3D_method_region_get_use_async_iterations>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_get_use_edge_connections<class_NavigationServer3D_method_region_get_use_edge_connections>`\ (\ region\: :ref:`RID<class_RID>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`region_owns_point<class_NavigationServer3D_method_region_owns_point>`\ (\ region\: :ref:`RID<class_RID>`, point\: :ref:`Vector3<class_Vector3>`\ ) |const| |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_enabled<class_NavigationServer3D_method_region_set_enabled>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_enter_cost<class_NavigationServer3D_method_region_set_enter_cost>`\ (\ region\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_map<class_NavigationServer3D_method_region_set_map>`\ (\ region\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_navigation_layers<class_NavigationServer3D_method_region_set_navigation_layers>`\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_navigation_mesh<class_NavigationServer3D_method_region_set_navigation_mesh>`\ (\ region\: :ref:`RID<class_RID>`, navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_owner_id<class_NavigationServer3D_method_region_set_owner_id>`\ (\ region\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_transform<class_NavigationServer3D_method_region_set_transform>`\ (\ region\: :ref:`RID<class_RID>`, transform\: :ref:`Transform3D<class_Transform3D>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_travel_cost<class_NavigationServer3D_method_region_set_travel_cost>`\ (\ region\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_use_async_iterations<class_NavigationServer3D_method_region_set_use_async_iterations>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`region_set_use_edge_connections<class_NavigationServer3D_method_region_set_use_edge_connections>`\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_active<class_NavigationServer3D_method_set_active>`\ (\ active\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_debug_enabled<class_NavigationServer3D_method_set_debug_enabled>`\ (\ enabled\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`simplify_path<class_NavigationServer3D_method_simplify_path>`\ (\ path\: :ref:`PackedVector3Array<class_PackedVector3Array>`, epsilon\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`RID<class_RID>` | :ref:`source_geometry_parser_create<class_NavigationServer3D_method_source_geometry_parser_create>`\ (\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`source_geometry_parser_set_callback<class_NavigationServer3D_method_source_geometry_parser_set_callback>`\ (\ parser\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) |
+-----------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Segnali
--------------
.. _class_NavigationServer3D_signal_avoidance_debug_changed:
.. rst-class:: classref-signal
**avoidance_debug_changed**\ (\ ) :ref:`🔗<class_NavigationServer3D_signal_avoidance_debug_changed>`
Emesso quando vengono modificate le impostazioni di debug di evasione. Disponibile solo nelle build di debug.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_signal_map_changed:
.. rst-class:: classref-signal
**map_changed**\ (\ map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_signal_map_changed>`
Emesso quando una mappa di navigazione viene aggiornata, quando una regione si sposta o viene modificata.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_signal_navigation_debug_changed:
.. rst-class:: classref-signal
**navigation_debug_changed**\ (\ ) :ref:`🔗<class_NavigationServer3D_signal_navigation_debug_changed>`
Emesso quando le impostazioni di debug di navigazione vengono modificate. Disponibile solo nelle build di debug.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Enumerazioni
------------------------
.. _enum_NavigationServer3D_ProcessInfo:
.. rst-class:: classref-enumeration
enum **ProcessInfo**: :ref:`🔗<enum_NavigationServer3D_ProcessInfo>`
.. _class_NavigationServer3D_constant_INFO_ACTIVE_MAPS:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_ACTIVE_MAPS** = ``0``
Costante per ottenere il numero di mappe di navigazione attive.
.. _class_NavigationServer3D_constant_INFO_REGION_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_REGION_COUNT** = ``1``
Costante per ottenere il numero di regioni di navigazione attive.
.. _class_NavigationServer3D_constant_INFO_AGENT_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_AGENT_COUNT** = ``2``
Costante per ottenere il numero di agenti di navigazione attivi che stanno elaborando l'evasione.
.. _class_NavigationServer3D_constant_INFO_LINK_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_LINK_COUNT** = ``3``
Costante per ottenere il numero di collegamenti di navigazione attivi.
.. _class_NavigationServer3D_constant_INFO_POLYGON_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_POLYGON_COUNT** = ``4``
Costante per ottenere il numero di poligoni di mesh di navigazione.
.. _class_NavigationServer3D_constant_INFO_EDGE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_EDGE_COUNT** = ``5``
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione.
.. _class_NavigationServer3D_constant_INFO_EDGE_MERGE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_EDGE_MERGE_COUNT** = ``6``
Constant to get the number of navigation mesh polygon edges that were merged due to edge key overlap.
.. _class_NavigationServer3D_constant_INFO_EDGE_CONNECTION_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_EDGE_CONNECTION_COUNT** = ``7``
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione che sono considerati collegati dalla prossimità dei bordi.
.. _class_NavigationServer3D_constant_INFO_EDGE_FREE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_EDGE_FREE_COUNT** = ``8``
Costante per ottenere il numero di bordi dei poligoni delle mesh di navigazione che non possono essere uniti ma che possono essere comunque collegati tramite prossimità dei bordi o tramite collegamenti.
.. _class_NavigationServer3D_constant_INFO_OBSTACLE_COUNT:
.. rst-class:: classref-enumeration-constant
:ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>` **INFO_OBSTACLE_COUNT** = ``9``
Costante per ottenere il numero di ostacoli di navigazione attivi.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_NavigationServer3D_method_agent_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **agent_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_agent_create>`
Crea l'agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_avoidance_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_get_avoidance_enabled**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_avoidance_enabled>`
Restituisce ``true`` se l'agente fornito ``agent`` ha l'evasione abilitata.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_avoidance_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_avoidance_layers**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_avoidance_layers>`
Restituisce la bitmask ``avoidance_layers`` dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_avoidance_mask:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_avoidance_mask**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_avoidance_mask>`
Restituisce il bitmask ``avoidance_mask`` dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_avoidance_priority:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_avoidance_priority**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_avoidance_priority>`
Restituisce l'``avoidance_priority`` dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_height:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_height**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_height>`
Restituisce il ``height`` dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **agent_get_map**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_map>`
Restituisce il :ref:`RID<class_RID>` della mappa di navigazione a cui è attualmente assegnato l'agente ``agent`` richiesto.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_max_neighbors:
.. rst-class:: classref-method
:ref:`int<class_int>` **agent_get_max_neighbors**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_max_neighbors>`
Restituisce il numero massimo di altri agenti che l'agente specificato ``agent`` tiene conto nella navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_max_speed:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_max_speed**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_max_speed>`
Restituisce la velocità massima dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_neighbor_distance:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_neighbor_distance**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_neighbor_distance>`
Restituisce la distanza massima da altri agenti che l'agente specificato ``agent`` tiene conto nella navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_paused:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_get_paused**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_paused>`
Restituisce ``true`` se l'agente specificato ``agent`` è in pausa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **agent_get_position**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_position>`
Restituisce la posizione dell'agente specificato ``agent`` in spazio mondiale.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_radius**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_radius>`
Restituisce il raggio dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_time_horizon_agents:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_time_horizon_agents**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_time_horizon_agents>`
Restituisce il periodo di tempo minimo per il quale le velocità dell'agente ``agent``, calcolate dalla simulazione, sono sicure rispetto ad altri agenti.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_time_horizon_obstacles:
.. rst-class:: classref-method
:ref:`float<class_float>` **agent_get_time_horizon_obstacles**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_time_horizon_obstacles>`
Restituisce il periodo di tempo minimo per il quale le velocità dell'agente ``agent``, calcolate dalla simulazione, sono sicure rispetto agli ostacoli di evasione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_use_3d_avoidance:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_get_use_3d_avoidance**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_use_3d_avoidance>`
Restituisce ``true`` se l'agente ``agent`` utilizza l'evasione nello spazio 3D Vector3(x,y,z) invece che nello spazio 2D orizzontale Vector2(x,y) / Vector3(x,0.0,z).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_get_velocity:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **agent_get_velocity**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_get_velocity>`
Restituisce la velocità dell'agente specificato ``agent``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_has_avoidance_callback:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_has_avoidance_callback**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_has_avoidance_callback>`
Restituisce ``true`` se l'agente ``agent`` ha un callback di evasione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_is_map_changed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **agent_is_map_changed**\ (\ agent\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_agent_is_map_changed>`
Restituisce ``true`` se la mappa è stata modificata nel frame precedente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_avoidance_callback:
.. rst-class:: classref-method
|void| **agent_set_avoidance_callback**\ (\ agent\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_avoidance_callback>`
Imposta il callback :ref:`Callable<class_Callable>` che viene chiamato dopo ogni fase di elaborazione dell'evasione per l'agente ``agent``. Il ``safe_velocity`` calcolato sarà inviato con un segnale all'oggetto appena prima dei calcoli della fisica.
\ **Nota:** I callback creati sono sempre elaborati a prescindere dallo stato del SceneTree fin quando l'agente si trova su una mappa di navigazione e non è liberato. Per disabilitare l'invio di un callback da un agente, utilizza di nuovo :ref:`agent_set_avoidance_callback()<class_NavigationServer3D_method_agent_set_avoidance_callback>` con un :ref:`Callable<class_Callable>` vuoto.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_avoidance_enabled:
.. rst-class:: classref-method
|void| **agent_set_avoidance_enabled**\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_avoidance_enabled>`
Se ``enabled`` è ``true``, l'agente fornito ``agent`` calcola l'elusione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_avoidance_layers:
.. rst-class:: classref-method
|void| **agent_set_avoidance_layers**\ (\ agent\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_avoidance_layers>`
Imposta la bitmask ``avoidance_layers`` dell'agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_avoidance_mask:
.. rst-class:: classref-method
|void| **agent_set_avoidance_mask**\ (\ agent\: :ref:`RID<class_RID>`, mask\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_avoidance_mask>`
Imposta la maschera di bit ``avoidance_mask`` dell'agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_avoidance_priority:
.. rst-class:: classref-method
|void| **agent_set_avoidance_priority**\ (\ agent\: :ref:`RID<class_RID>`, priority\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_avoidance_priority>`
Imposta la priorità di evasione (``avoidance_priority``) dell'agente su ``priority``, compreso tra 0,0 (priorità più bassa) e 1,0 (priorità più alta).
L'agente ``agent`` specificato non regola la velocità per altri agenti che corrisponderebbero alla maschera (``avoidance_mask``) ma hanno una priorità (``avoidance_priority``) inferiore. Ciò a sua volta fa in modo che gli altri agenti con priorità inferiore regolino ulteriormente le loro velocità per evitare collisioni con questo agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_height:
.. rst-class:: classref-method
|void| **agent_set_height**\ (\ agent\: :ref:`RID<class_RID>`, height\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_height>`
Aggiorna l'altezza dell'agente ``agent`` su ``height``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_map:
.. rst-class:: classref-method
|void| **agent_set_map**\ (\ agent\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_map>`
Mette l'agente nella mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_max_neighbors:
.. rst-class:: classref-method
|void| **agent_set_max_neighbors**\ (\ agent\: :ref:`RID<class_RID>`, count\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_max_neighbors>`
Imposta il numero massimo di altri agenti che l'agente prende in considerazione nella navigazione. Maggiore è questo numero, più lungo sarà il tempo di esecuzione della simulazione. Se il numero è troppo basso, la simulazione non sarà sicura.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_max_speed:
.. rst-class:: classref-method
|void| **agent_set_max_speed**\ (\ agent\: :ref:`RID<class_RID>`, max_speed\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_max_speed>`
Imposta la velocità massima dell'agente. Dev'essere positiva.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_neighbor_distance:
.. rst-class:: classref-method
|void| **agent_set_neighbor_distance**\ (\ agent\: :ref:`RID<class_RID>`, distance\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_neighbor_distance>`
Imposta la distanza massima da altri agenti che questo agente prende in considerazione nella navigazione. Maggiore è questo numero, più lungo sarà il tempo di esecuzione della simulazione. Se il numero è troppo basso, la simulazione non sarà sicura.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_paused:
.. rst-class:: classref-method
|void| **agent_set_paused**\ (\ agent\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_paused>`
Se ``paused`` è ``true``, l'agente ``agent`` non sarà elaborato. Ad esempio, non calcolerà le velocità di evasione o riceverà i callback di evasione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_position:
.. rst-class:: classref-method
|void| **agent_set_position**\ (\ agent\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_position>`
Imposta la posizione dell'agente nello spazio mondiale.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_radius:
.. rst-class:: classref-method
|void| **agent_set_radius**\ (\ agent\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_radius>`
Imposta il raggio dell'agente.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_time_horizon_agents:
.. rst-class:: classref-method
|void| **agent_set_time_horizon_agents**\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_time_horizon_agents>`
La quantità minima di tempo per cui le velocità dell'agente calcolate dalla simulazione sono sicure rispetto ad altri agenti. Maggiore è questo numero, prima questo agente risponderà alla presenza di altri agenti, ma minore sarà la libertà che questo agente ha nello scegliere le sue velocità. Un valore troppo alto rallenterà notevolmente il movimento degli agenti. Deve essere positivo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_time_horizon_obstacles:
.. rst-class:: classref-method
|void| **agent_set_time_horizon_obstacles**\ (\ agent\: :ref:`RID<class_RID>`, time_horizon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_time_horizon_obstacles>`
La quantità minima di tempo per cui le velocità dell'agente calcolate dalla simulazione sono sicure rispetto agli ostacoli statici di evasione. Maggiore è questo numero, prima questo agente risponderà alla presenza di ostacoli statici di evasione, ma minore è la libertà che questo agente ha nello scegliere le sue velocità. Un valore troppo alto rallenterà notevolmente il movimento degli agenti. Deve essere positivo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_use_3d_avoidance:
.. rst-class:: classref-method
|void| **agent_set_use_3d_avoidance**\ (\ agent\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_use_3d_avoidance>`
Imposta se l'agente usa l'evasione 2D o l'evasione 3D mentre l'evasione è abilitata.
Se ``true`` l'agente calcola le velocità di evasione in 3D per l'asse xyz, ad esempio per i giochi che si svolgono in aria, sott'acqua o nello spazio. Gli agenti che utilizzano l'evasione 3D evitano solo gli altri agenti che utilizzano l'evasione 3D. Inoltre, essi reagiscono solo agli ostacoli di evasione basati sui raggi, ignorando tutti gli ostacoli basati sui vertici.
Se ``false`` l'agente calcola le velocità di evasione in 2D lungo l'asse xz ignorando l'asse y. Gli agenti che utilizzano l'evasione 2D evitano solo altri agenti utilizzano l'evasione 2D. Inoltre, essi reagiscono agli ostacoli di evasione basati sui raggi e sui vertici. Infine, essi 2D ignoreranno gli altri agenti che utilizzano l'evasione 2D o gli ostacoli che si trovano al di sotto o al di sopra della loro posizione attuale, inclusa l'altezza dell'agente nell'evasione 2D.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_velocity:
.. rst-class:: classref-method
|void| **agent_set_velocity**\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_velocity>`
Imposta ``velocity`` come la nuova velocità desiderata per l'agente ``agent``. La simulazione dell'evasione cercherà di soddisfare questa velocità se possibile, ma la modificherà per evitare collisioni con altri agenti e ostacoli. Quando un agente viene teletrasportato in una nuova posizione, usa anche :ref:`agent_set_velocity_forced()<class_NavigationServer3D_method_agent_set_velocity_forced>` per reimpostare la velocità interna di simulazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_agent_set_velocity_forced:
.. rst-class:: classref-method
|void| **agent_set_velocity_forced**\ (\ agent\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_agent_set_velocity_forced>`
Sostituisce la velocità interna nella simulazione di evasione delle collisioni con ``velocity`` per l'agente ``agent``. Quando un agente è teletrasportato in una nuova posizione, questa funzione dovrebbe essere utilizzata nello stesso frame. Se chiamata spesso, questa funzione può bloccare gli agenti.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_bake_from_source_geometry_data:
.. rst-class:: classref-method
|void| **bake_from_source_geometry_data**\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer3D_method_bake_from_source_geometry_data>`
Prepara la mesh di navigazione ``navigation_mesh`` con i dati della geometria sorgente ``source_geometry_data``. Una volta terminato il processo, verrà chiamato il ``callback`` facoltativo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_bake_from_source_geometry_data_async:
.. rst-class:: classref-method
|void| **bake_from_source_geometry_data_async**\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer3D_method_bake_from_source_geometry_data_async>`
Prepara la mesh di navigazione ``navigation_mesh`` con i dati della geometria sorgente ``source_geometry_data`` come un'attività asincrona in esecuzione su un thread in background. Una volta terminato il processo, verrà chiamato il ``callback`` facoltativo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_free_rid:
.. rst-class:: classref-method
|void| **free_rid**\ (\ rid\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_free_rid>`
Distrugge il RID specificato.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_get_debug_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **get_debug_enabled**\ (\ ) |const| :ref:`🔗<class_NavigationServer3D_method_get_debug_enabled>`
Restituisce ``true`` quando il NavigationServer ha il debug abilitato.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_get_maps:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **get_maps**\ (\ ) |const| :ref:`🔗<class_NavigationServer3D_method_get_maps>`
Restituisce tutti i :ref:`RID<class_RID>` delle mappe di navigazione create sul NavigationServer. Restituisce sia le mappe di navigazione create in 2D sia quelle in 3D, poiché tecnicamente non c'è distinzione tra loro.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_get_process_info:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_process_info**\ (\ process_info\: :ref:`ProcessInfo<enum_NavigationServer3D_ProcessInfo>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_get_process_info>`
Restituisce informazioni sullo stato attuale del NavigationServer.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_is_baking_navigation_mesh:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_baking_navigation_mesh**\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_is_baking_navigation_mesh>`
Restituisce ``true`` quando la mesh di navigazione fornita è in fase di preparazione su un thread in background.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **link_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_link_create>`
Crea un nuovo collegamento tra due posizioni su una mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **link_get_enabled**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_enabled>`
Restituisce ``true`` se il collegamento ``link`` specificato è abilitato.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_end_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **link_get_end_position**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_end_position>`
Restituisce la posizione finale di questo collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_enter_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **link_get_enter_cost**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_enter_cost>`
Restituisce il costo di entrata di questo collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_iteration_id**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_iteration_id>`
Restituisce l'ID d'iterazione attuale del collegamento di navigazione. Ogni volta che il collegamento di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a ``0`` significa che il collegamento di navigazione non si è mai sincronizzato.
\ **Nota:** L'ID d'iterazione ritornerà a ``1`` dopo aver raggiunto il suo limite di intervallo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **link_get_map**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_map>`
Restituisce il :ref:`RID<class_RID>` della mappa di navigazione a cui è attualmente assegnato il collegamento (``link``) richiesto.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_navigation_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_navigation_layers**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_navigation_layers>`
Restituisce gli strati di navigazione per questo collegamento (``link``).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_owner_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **link_get_owner_id**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_owner_id>`
Restituisce il ``ObjectID`` dell'oggetto che gestisce questo collegamento.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_start_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **link_get_start_position**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_start_position>`
Restituisce la posizione di partenza di questo collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_get_travel_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **link_get_travel_cost**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_get_travel_cost>`
Restituisce il costo di viaggio di questo collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_is_bidirectional:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **link_is_bidirectional**\ (\ link\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_link_is_bidirectional>`
Restituisce se questo collegamento ``link`` può essere viaggiato in entrambe le direzioni.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_bidirectional:
.. rst-class:: classref-method
|void| **link_set_bidirectional**\ (\ link\: :ref:`RID<class_RID>`, bidirectional\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_bidirectional>`
Imposta se questo collegamento ``link`` può essere viaggiato in entrambe le direzioni.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_enabled:
.. rst-class:: classref-method
|void| **link_set_enabled**\ (\ link\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_enabled>`
Se ``enabled`` è ``true``, il collegamento specificato ``link`` contribuirà alla sua attuale mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_end_position:
.. rst-class:: classref-method
|void| **link_set_end_position**\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_end_position>`
Imposta la posizione di uscita per il collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_enter_cost:
.. rst-class:: classref-method
|void| **link_set_enter_cost**\ (\ link\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_enter_cost>`
Imposta il costo di entrata per questo collegamento ``link`` a ``enter_cost``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_map:
.. rst-class:: classref-method
|void| **link_set_map**\ (\ link\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_map>`
Imposta il :ref:`RID<class_RID>` della mappa di navigazione per il collegamento.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_navigation_layers:
.. rst-class:: classref-method
|void| **link_set_navigation_layers**\ (\ link\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_navigation_layers>`
Imposta gli strati di navigazione dei collegamento. Ciò consente di selezionare i collegamenti da una richiesta di percorso (quando si utilizza :ref:`map_get_path()<class_NavigationServer3D_method_map_get_path>`).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_owner_id:
.. rst-class:: classref-method
|void| **link_set_owner_id**\ (\ link\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_owner_id>`
Imposta l'``ObjectID`` dell'oggetto che gestisce questo collegamento.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_start_position:
.. rst-class:: classref-method
|void| **link_set_start_position**\ (\ link\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_start_position>`
Imposta la posizione di ingresso per questo collegamento ``link``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_link_set_travel_cost:
.. rst-class:: classref-method
|void| **link_set_travel_cost**\ (\ link\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_link_set_travel_cost>`
Imposta il costo di viaggio per questo collegamento ``link`` a ``travel_cost``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **map_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_map_create>`
Crea una nuova mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_force_update:
.. rst-class:: classref-method
|void| **map_force_update**\ (\ map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_force_update>`
**Deprecato:** This method is no longer supported, as it is incompatible with asynchronous updates. It can only be used in a single-threaded context, at your own risk.
Questa funzione forza immediatamente la sincronizzazione della mappa di navigazione specificata con il :ref:`RID<class_RID>` ``map``. Come predefinito, le mappe di navigazione vengono sincronizzate solo alla fine di ogni frame di fisica. Questa funzione può essere utilizzata per (ri)calcolare immediatamente tutte le mesh di navigazione e le connessioni tra regioni della mappa di navigazione. Ciò consente di interrogare un percorso di navigazione per una mappa modificata immediatamente e nello stesso frame (più volte se necessario).
A causa di restrizioni tecniche, la coda attuale dei comandi del NavigationServer verrà svuotata. Ciò significa che tutti i comandi di aggiornamento già in coda per questo frame di fisica verranno eseguiti, anche quelli destinati ad altre mappe, regioni e agenti che non fanno parte della mappa specificata. Il costoso calcolo delle mesh di navigazione e delle connessioni tra regioni di una mappa verrà eseguito solo per la mappa specificata. Le altre mappe riceveranno la normale sincronizzazione alla fine del frame di fisica. Se la mappa specificata riceve modifiche dopo l'aggiornamento forzato, verrà aggiornata di nuovo anche quando le altre mappe riceveranno il loro aggiornamento.
L'elaborazione dell'evasione e l'invio dei segnali ``safe_velocity`` non sono influenzati da questa funzione e continuano ad accadere per tutte le mappe e gli agenti alla fine del frame di fisica.
\ **Nota:** Da un grande potere derivano grandi responsabilità. Questa funzione dovrebbe essere utilizzata solo da utenti che sanno davvero cosa stanno facendo e hanno una buona ragione per farlo. Forzare un aggiornamento immediato di una mappa di navigazione richiede il blocco del NavigationServer e lo svuotamento dell'intera coda dei comandi del NavigationServer. Ciò non solo può avere un impatto significativo sulle prestazioni di un gioco, ma può anche introdurre bug se utilizzato in modo inappropriato senza molta prudenza.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_agents:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_agents**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_agents>`
Restituisce i :ref:`RID<class_RID>` di tutti gli agenti di navigazione attualmente assegnati alla mappa di navigazione (``map``) richiesta.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_cell_height:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_cell_height**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_cell_height>`
Restituisce l'altezza delle celle della mappa utilizzata per rasterizzare i vertici della mesh di navigazione sull'asse Y.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_cell_size:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_cell_size**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_cell_size>`
Restituisce le dimensioni delle celle della mappa utilizzate per rasterizzare i vertici della mesh di navigazione sul piano XZ.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_closest_point:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_get_closest_point**\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_closest_point>`
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al punto ``to_point`` sulla mappa di navigazione ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_closest_point_normal:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_get_closest_point_normal**\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_closest_point_normal>`
Restituisce la normale sulla superfice della mesh di navigazione più vicina al punto ``to_point`` sulla superficie della mappa di navigazione ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_closest_point_owner:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **map_get_closest_point_owner**\ (\ map\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_closest_point_owner>`
Restituisce il RID proprietario di regione per il punto sulla superfice della mesh di navigazione che è più vicino al punto ``to_point`` sulla mappa di navigazione ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_closest_point_to_segment:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_get_closest_point_to_segment**\ (\ map\: :ref:`RID<class_RID>`, start\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, use_collision\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_closest_point_to_segment>`
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al segmento fornito (``start`` e ``end``) sulla mappa di navigazione ``map``.
Se ``use_collision`` è ``true``, un test del punto più vicino viene eseguito solo quando il segmento interseca la superficie della mesh di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_edge_connection_margin:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_edge_connection_margin**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_edge_connection_margin>`
Restituisce il margine di connessione ai bordi della mappa. Questa distanza è la distanza minima del vertice necessaria per connettere due bordi da regioni diverse.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **map_get_iteration_id**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_iteration_id>`
Restituisce l'ID d'iterazione attuale della mappa di navigazione. Ogni volta che la mappa di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a 0 significa che la mappa di navigazione non si è mai sincronizzata.
\ **Nota:** L'ID d'iterazione tornerà a 1 dopo aver raggiunto il limite di intervallo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_link_connection_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_link_connection_radius**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_link_connection_radius>`
Restituisce il raggio di connessione del collegamento nella mappa. Questa distanza è l'intervallo massimo in cui un collegamento cercherà i poligoni dei mesh di navigazione a cui collegarsi.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_links:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_links**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_links>`
Restituisce gli :ref:`RID<class_RID>` di tutti i collegamenti di navigazione che sono attualmente assegnati alla mappa di navigazione richiesta ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_merge_rasterizer_cell_scale:
.. rst-class:: classref-method
:ref:`float<class_float>` **map_get_merge_rasterizer_cell_scale**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_merge_rasterizer_cell_scale>`
Restituisce la scala delle celle del rasterizzatore interno di unione della mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_obstacles:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_obstacles**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_obstacles>`
Restituisce i :ref:`RID<class_RID>` di tutti gli ostacoli di navigazione attualmente assegnati alla mappa di navigazione specificata da ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_path:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **map_get_path**\ (\ map\: :ref:`RID<class_RID>`, origin\: :ref:`Vector3<class_Vector3>`, destination\: :ref:`Vector3<class_Vector3>`, optimize\: :ref:`bool<class_bool>`, navigation_layers\: :ref:`int<class_int>` = 1\ ) :ref:`🔗<class_NavigationServer3D_method_map_get_path>`
Restituisce il percorso di navigazione per raggiungere la destinazione dall'origine. ``navigation_layers`` è una maschera di bit di tutti gli strati di navigazione della regione che possono essere presenti nel percorso.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_random_point:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_get_random_point**\ (\ map\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_random_point>`
Restituisce una posizione casuale selezionata da tutti i poligoni della regione della mappa con gli strati di navigazione corrispondenti a ``navigation_layers``.
Se ``uniformly`` è ``true``, tutte le regioni della mappa, i poligoni e le facce sono pesati in base alla loro area superficiale (più lento).
Se ``uniformly`` è ``false``, solo una regione casuale e un poligono casuale sono selezionati (più veloce).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_regions:
.. rst-class:: classref-method
:ref:`Array<class_Array>`\[:ref:`RID<class_RID>`\] **map_get_regions**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_regions>`
Restituisce tutti i :ref:`RID<class_RID>` delle regioni di navigazione attualmente assegnate alla mappa di navigazione specificata da ``map``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_up:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **map_get_up**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_up>`
Restituisce la direzione in alto per la mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_use_async_iterations:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_get_use_async_iterations**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_use_async_iterations>`
Restituisce ``true`` se la sincronizzazione della mappa ``map`` usa un processo asincrono che viene eseguito su un thread in background.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_get_use_edge_connections:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_get_use_edge_connections**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_get_use_edge_connections>`
Restituisce ``true`` se la mappa di navigazione ``map`` consente alle regioni di navigazione di utilizzare connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_is_active:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **map_is_active**\ (\ map\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_map_is_active>`
Restituisce ``true`` se la mappa è attiva.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_active:
.. rst-class:: classref-method
|void| **map_set_active**\ (\ map\: :ref:`RID<class_RID>`, active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_active>`
Imposta la mappa come attiva.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_cell_height:
.. rst-class:: classref-method
|void| **map_set_cell_height**\ (\ map\: :ref:`RID<class_RID>`, cell_height\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_cell_height>`
Imposta l'altezza delle celle della mappa utilizzata per rasterizzare i vertici della mesh di navigazione sull'asse Y. Deve corrispondere all'altezza delle celle delle mesh di navigazione utilizzate.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_cell_size:
.. rst-class:: classref-method
|void| **map_set_cell_size**\ (\ map\: :ref:`RID<class_RID>`, cell_size\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_cell_size>`
Imposta le dimensioni delle celle della mappa utilizzate per rasterizzare i vertici della mesh di navigazione sul piano XZ. Deve corrispondere alle dimensioni delle celle delle mesh di navigazione utilizzate.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_edge_connection_margin:
.. rst-class:: classref-method
|void| **map_set_edge_connection_margin**\ (\ map\: :ref:`RID<class_RID>`, margin\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_edge_connection_margin>`
Imposta il margine di connessione ai bordi della mappa utilizzato per unire i bordi delle regioni compatibili.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_link_connection_radius:
.. rst-class:: classref-method
|void| **map_set_link_connection_radius**\ (\ map\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_link_connection_radius>`
Imposta il raggio di connessione dei collegamenti della mappa utilizzato per collegare i collegamenti ai poligoni di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_merge_rasterizer_cell_scale:
.. rst-class:: classref-method
|void| **map_set_merge_rasterizer_cell_scale**\ (\ map\: :ref:`RID<class_RID>`, scale\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_merge_rasterizer_cell_scale>`
Imposta la scala delle celle del rasterizzatore interno di unione della mappa, utilizzata per controllare la sensibilità dell'unione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_up:
.. rst-class:: classref-method
|void| **map_set_up**\ (\ map\: :ref:`RID<class_RID>`, up\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_up>`
Imposta la direzione in alto per la mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_use_async_iterations:
.. rst-class:: classref-method
|void| **map_set_use_async_iterations**\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_use_async_iterations>`
Se ``enabled`` è ``true``, la sincronizzazione della mappa ``map`` usa un processo asincrono che viene eseguito su un thread in background.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_map_set_use_edge_connections:
.. rst-class:: classref-method
|void| **map_set_use_edge_connections**\ (\ map\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_map_set_use_edge_connections>`
Imposta l'uso della connessione ai bordi della mappa di navigazione ``map``. Se ``enabled`` è ``true``, la mappa di navigazione consente alle regioni di navigazione di usare connessioni ai bordi per connettersi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **obstacle_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_create>`
Crea un nuovo ostacolo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_avoidance_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **obstacle_get_avoidance_enabled**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_avoidance_enabled>`
Restituisce ``true`` se l'ostacolo fornito ``obstacle`` ha l'evasione abilitata.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_avoidance_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **obstacle_get_avoidance_layers**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_avoidance_layers>`
Restituisce il bitmask ``avoidance_layers`` dell'ostacolo specificato ``obstacle``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_height:
.. rst-class:: classref-method
:ref:`float<class_float>` **obstacle_get_height**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_height>`
Restituisce la ``height`` dell'ostacolo specificato ``obstacle``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **obstacle_get_map**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_map>`
Restituisce il :ref:`RID<class_RID>` della mappa di navigazione a cui è attualmente assegnato l'ostacolo (``obstacle``) richiesto.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_paused:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **obstacle_get_paused**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_paused>`
Restituisce ``true`` se l'ostacolo specificato ``obstacle`` è in pausa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_position:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **obstacle_get_position**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_position>`
Restituisce la posizione dell'ostacolo specificato ``obstacle`` in spazio mondiale.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_radius:
.. rst-class:: classref-method
:ref:`float<class_float>` **obstacle_get_radius**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_radius>`
Restituisce il raggio dell'ostacolo dinamico specificato ``obstacle``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_use_3d_avoidance:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **obstacle_get_use_3d_avoidance**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_use_3d_avoidance>`
Restituisce ``true`` se l'ostacolo ``obstacle`` utilizza l'evasione nello spazio 3D Vector3(x,y,z) invece di Vector2(x,y) orizzontale 2D (x,y) / Vector3(x,0.0,z).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_velocity:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **obstacle_get_velocity**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_velocity>`
Restituisce la velocità dell'ostacolo dinamico specificato ``obstacle``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_get_vertices:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **obstacle_get_vertices**\ (\ obstacle\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_obstacle_get_vertices>`
Restituisce i vertici dei contorni per l'ostacolo specificato ``obstacle``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_avoidance_enabled:
.. rst-class:: classref-method
|void| **obstacle_set_avoidance_enabled**\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_avoidance_enabled>`
Se ``enabled`` è ``true``, l'ostacolo fornito ``obstacle`` influisce sull'evitasione usando degli agenti.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_avoidance_layers:
.. rst-class:: classref-method
|void| **obstacle_set_avoidance_layers**\ (\ obstacle\: :ref:`RID<class_RID>`, layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_avoidance_layers>`
Imposta il bitmask ``avoidance_layers`` dell'ostacolo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_height:
.. rst-class:: classref-method
|void| **obstacle_set_height**\ (\ obstacle\: :ref:`RID<class_RID>`, height\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_height>`
Imposta l'altezza dell'ostacolo ``obstacle`` su ``height``. In 3D gli agenti ignoreranno gli ostacoli che si trovano sopra o sotto di loro mentre utilizzano l'evasione 2D.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_map:
.. rst-class:: classref-method
|void| **obstacle_set_map**\ (\ obstacle\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_map>`
Assegna l'ostacolo ``obstacle`` a una mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_paused:
.. rst-class:: classref-method
|void| **obstacle_set_paused**\ (\ obstacle\: :ref:`RID<class_RID>`, paused\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_paused>`
Se ``paused`` è ``true`` l'ostacolo ``obstacle`` non sarà elaborato. Ad esempio, non influirà più sulle velocità di evasione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_position:
.. rst-class:: classref-method
|void| **obstacle_set_position**\ (\ obstacle\: :ref:`RID<class_RID>`, position\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_position>`
Aggiorna la posizione per l'ostacolo ``obstacle`` a ``position`` in spazio mondiale.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_radius:
.. rst-class:: classref-method
|void| **obstacle_set_radius**\ (\ obstacle\: :ref:`RID<class_RID>`, radius\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_radius>`
Imposta il raggio dell'ostacolo dinamico.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_use_3d_avoidance:
.. rst-class:: classref-method
|void| **obstacle_set_use_3d_avoidance**\ (\ obstacle\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_use_3d_avoidance>`
Imposta se l'ostacolo ``obstacle`` utilizza l'evasione 2D o l'evasione 3D mentre l'evasione è abilitata.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_velocity:
.. rst-class:: classref-method
|void| **obstacle_set_velocity**\ (\ obstacle\: :ref:`RID<class_RID>`, velocity\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_velocity>`
Imposta la velocità dell'ostacolo ``obstacle`` dinamico su ``velocity``. Consente ad altri agenti di prevedere meglio il movimento dell'ostacolo dinamico. Funziona solo in combinazione con il raggio dell'ostacolo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_obstacle_set_vertices:
.. rst-class:: classref-method
|void| **obstacle_set_vertices**\ (\ obstacle\: :ref:`RID<class_RID>`, vertices\: :ref:`PackedVector3Array<class_PackedVector3Array>`\ ) :ref:`🔗<class_NavigationServer3D_method_obstacle_set_vertices>`
Imposta i vertici di contorno per l'ostacolo. Se i vertici sono avvolti in senso orario, gli agenti saranno spinti dentro dall'ostacolo, altrimenti saranno spinti fuori.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_parse_source_geometry_data:
.. rst-class:: classref-method
|void| **parse_source_geometry_data**\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, source_geometry_data\: :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>`, root_node\: :ref:`Node<class_Node>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer3D_method_parse_source_geometry_data>`
Analizza il :ref:`SceneTree<class_SceneTree>` per la geometria sorgente in base alle proprietà di ``navigation_mesh``. Aggiorna la risorsa ``source_geometry_data`` fornita con i dati risultanti. La risorsa può quindi essere utilizzata per preparare una mesh di navigazione con :ref:`bake_from_source_geometry_data()<class_NavigationServer3D_method_bake_from_source_geometry_data>`. Dopo che il processo è terminato, verrà chiamato il ``callback`` facoltativo.
\ **Nota:** Questa funzione deve essere eseguita sul thread principale o con una chiamata differita poiché il SceneTree non è sicuro su altri thread.
\ **Prestazioni:** Sebbene sia conveniente, leggere gli array di dati dalle risorse :ref:`Mesh<class_Mesh>` può influire negativamente sul frame rate. I dati devono essere ricevuti dalla GPU, bloccando il :ref:`RenderingServer<class_RenderingServer>` nel processo. Per le prestazioni, si preferisce utilizzare, ad esempio, forme di collisione o creare gli array di dati interamente in codice.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_query_path:
.. rst-class:: classref-method
|void| **query_path**\ (\ parameters\: :ref:`NavigationPathQueryParameters3D<class_NavigationPathQueryParameters3D>`, result\: :ref:`NavigationPathQueryResult3D<class_NavigationPathQueryResult3D>`, callback\: :ref:`Callable<class_Callable>` = Callable()\ ) :ref:`🔗<class_NavigationServer3D_method_query_path>`
Ricerca un percorso in una mappa di navigazione specificata. La posizione di partenza e di arrivo e altri parametri sono definiti tramite :ref:`NavigationPathQueryParameters3D<class_NavigationPathQueryParameters3D>`. Aggiorna l'oggetto fornito :ref:`NavigationPathQueryParameters3D<class_NavigationPathQueryParameters3D>` risultante con il percorso, assieme agli altri risultati richiesti dalla query. Dopo che il processo ha terminato, verrà chiamato il ``callback`` facoltativo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_bake_navigation_mesh:
.. rst-class:: classref-method
|void| **region_bake_navigation_mesh**\ (\ navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`, root_node\: :ref:`Node<class_Node>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_bake_navigation_mesh>`
**Deprecato:** This method is deprecated due to core threading changes. To upgrade existing code, first create a :ref:`NavigationMeshSourceGeometryData3D<class_NavigationMeshSourceGeometryData3D>` resource. Use this resource with :ref:`parse_source_geometry_data()<class_NavigationServer3D_method_parse_source_geometry_data>` to parse the :ref:`SceneTree<class_SceneTree>` for nodes that should contribute to the navigation mesh baking. The :ref:`SceneTree<class_SceneTree>` parsing needs to happen on the main thread. After the parsing is finished use the resource with :ref:`bake_from_source_geometry_data()<class_NavigationServer3D_method_bake_from_source_geometry_data>` to bake a navigation mesh.
Prepara la mesh di navigazione ``navigation_mesh`` con la geometria sorgente raccolta a partire dal nodo radice ``root_node``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **region_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_region_create>`
Crea una nuova regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_bounds:
.. rst-class:: classref-method
:ref:`AABB<class_AABB>` **region_get_bounds**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_bounds>`
Restituisce la bounding box allineata agli assi per la mesh trasformata di navigazione della regione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_closest_point:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_closest_point**\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_closest_point>`
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al punto ``to_point`` sulla regione di navigazione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_closest_point_normal:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_closest_point_normal**\ (\ region\: :ref:`RID<class_RID>`, to_point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_closest_point_normal>`
Restituisce la normale sulla superfice della mesh di navigazione più vicina al punto ``to_point`` sulla superficie della regione di navigazione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_closest_point_to_segment:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_closest_point_to_segment**\ (\ region\: :ref:`RID<class_RID>`, start\: :ref:`Vector3<class_Vector3>`, end\: :ref:`Vector3<class_Vector3>`, use_collision\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_closest_point_to_segment>`
Restituisce il punto sulla superfice della mesh di navigazione che è più vicino al segmento fornito (``start`` e ``end``) sulla regione di navigazione ``region``.
Se ``use_collision`` è ``true``, un test del punto più vicino viene eseguito solo quando il segmento interseca la superficie della mesh di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_connection_pathway_end:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_connection_pathway_end**\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_connection_pathway_end>`
Restituisce il punto finale di una porta di connessione. ``connection`` è un indice compreso tra 0 e il valore restituito di :ref:`region_get_connections_count()<class_NavigationServer3D_method_region_get_connections_count>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_connection_pathway_start:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_connection_pathway_start**\ (\ region\: :ref:`RID<class_RID>`, connection\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_connection_pathway_start>`
Restituisce il punto iniziale di una porta di connessione. ``connection`` è un indice compreso tra 0 e il valore restituito di :ref:`region_get_connections_count()<class_NavigationServer3D_method_region_get_connections_count>`.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_connections_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_connections_count**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_connections_count>`
Restituisce il numero di collegamenti che la regione ``region`` ha con altre regioni nella mappa.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_enabled:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_enabled**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_enabled>`
Restituisce ``true`` se la regione specifica ``region`` è abilitata.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_enter_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **region_get_enter_cost**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_enter_cost>`
Restituisce il costo di entrata di questa regione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_iteration_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_iteration_id**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_iteration_id>`
Restituisce l'ID d'iterazione attuale della regione di navigazione. Ogni volta che la regione di navigazione cambia e si sincronizza, l'ID d'iterazione aumenta. Un ID d'iterazione pari a ``0`` significa che la regione di navigazione non si è mai sincronizzata.
\ **Nota:** L'ID d'iterazione ritornerà a ``1`` dopo aver raggiunto il suo limite di intervallo.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_map:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **region_get_map**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_map>`
Restituisce il :ref:`RID<class_RID>` della mappa di navigazione a cui è attualmente assegnata la regione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_navigation_layers:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_navigation_layers**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_navigation_layers>`
Restituisce gli strati di navigazione della regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_owner_id:
.. rst-class:: classref-method
:ref:`int<class_int>` **region_get_owner_id**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_owner_id>`
Restituisce il ``ObjectID`` dell'oggetto che gestisce questa regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_random_point:
.. rst-class:: classref-method
:ref:`Vector3<class_Vector3>` **region_get_random_point**\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`, uniformly\: :ref:`bool<class_bool>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_random_point>`
Restituisce una posizione casuale selezionata da tutti i poligoni della regione con gli strati di navigazione corrispondenti a ``navigation_layers``.
Se ``uniformly`` è ``true``, tutti i poligoni e le facce della regione sono pesati in base alla loro area superficiale (più lento).
Se ``uniformly`` è ``false``, solo un poligono casuale e una faccia sono selezionati (più veloce).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_transform:
.. rst-class:: classref-method
:ref:`Transform3D<class_Transform3D>` **region_get_transform**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_transform>`
Restituisce la trasformazione globale di questa ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_travel_cost:
.. rst-class:: classref-method
:ref:`float<class_float>` **region_get_travel_cost**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_travel_cost>`
Restituisce il costo di viaggio di questa regione ``region``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_use_async_iterations:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_use_async_iterations**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_use_async_iterations>`
Restituisce ``true`` se la regione ``region`` usa un processo asincrono che viene eseguito su un thread in background.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_get_use_edge_connections:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_get_use_edge_connections**\ (\ region\: :ref:`RID<class_RID>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_get_use_edge_connections>`
Restituisce ``true`` se la regione di navigazione ``region`` è impostata per utilizzare le connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_owns_point:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **region_owns_point**\ (\ region\: :ref:`RID<class_RID>`, point\: :ref:`Vector3<class_Vector3>`\ ) |const| :ref:`🔗<class_NavigationServer3D_method_region_owns_point>`
Restituisce ``true`` se il punto ``point`` nello spazio mondiale è attualmente appartenente alla regione di navigazione ``region``. "Appartenente" in questo contesto significa che una delle facce del poligono della mesh di navigazione della regione ha una possibile posizione alla distanza più vicina a questo punto rispetto a tutte le altre mesh di navigazione da altre regioni di navigazione che sono registrate sulla stessa mappa di navigazione della regione.
Se più mesh di navigazione hanno posizioni a uguale distanza, la regione di navigazione i cui poligoni sono elaborati per primi vince l'appartenenza. I poligoni sono elaborati nello stesso ordine in cui le regioni di navigazione sono state registrate sul NavigationServer.
\ **Nota:** Se le mesh di navigazione da diverse regioni di navigazione si sovrappongono (cosa che si dovrebbe evitare in generale), il risultato potrebbe non essere quello previsto.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_enabled:
.. rst-class:: classref-method
|void| **region_set_enabled**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_enabled>`
Se ``enabled`` è ``true`` la regione specificata ``region`` contribuirà alla sua attuale mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_enter_cost:
.. rst-class:: classref-method
|void| **region_set_enter_cost**\ (\ region\: :ref:`RID<class_RID>`, enter_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_enter_cost>`
Imposta il costo di entrata per questa regione ``region`` a ``enter_cost``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_map:
.. rst-class:: classref-method
|void| **region_set_map**\ (\ region\: :ref:`RID<class_RID>`, map\: :ref:`RID<class_RID>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_map>`
Imposta la mappa per la regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_navigation_layers:
.. rst-class:: classref-method
|void| **region_set_navigation_layers**\ (\ region\: :ref:`RID<class_RID>`, navigation_layers\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_navigation_layers>`
Imposta gli strati di navigazione della regione. Ciò consente di selezionare regioni da una ricerca di percorso (quando si utilizza :ref:`map_get_path()<class_NavigationServer3D_method_map_get_path>`).
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_navigation_mesh:
.. rst-class:: classref-method
|void| **region_set_navigation_mesh**\ (\ region\: :ref:`RID<class_RID>`, navigation_mesh\: :ref:`NavigationMesh<class_NavigationMesh>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_navigation_mesh>`
Imposta la mesh di navigazione per la regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_owner_id:
.. rst-class:: classref-method
|void| **region_set_owner_id**\ (\ region\: :ref:`RID<class_RID>`, owner_id\: :ref:`int<class_int>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_owner_id>`
Imposta il ``ObjectID`` dell'oggetto che gestisce questa regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_transform:
.. rst-class:: classref-method
|void| **region_set_transform**\ (\ region\: :ref:`RID<class_RID>`, transform\: :ref:`Transform3D<class_Transform3D>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_transform>`
Imposta la trasformazione globale per la regione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_travel_cost:
.. rst-class:: classref-method
|void| **region_set_travel_cost**\ (\ region\: :ref:`RID<class_RID>`, travel_cost\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_travel_cost>`
Imposta il costo di viaggio per questa regione ``region`` a ``travel_cost``.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_use_async_iterations:
.. rst-class:: classref-method
|void| **region_set_use_async_iterations**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_use_async_iterations>`
Se ``enabled`` è ``true``, la regione ``region`` usa un processo asincrono che viene eseguito su un thread in background.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_region_set_use_edge_connections:
.. rst-class:: classref-method
|void| **region_set_use_edge_connections**\ (\ region\: :ref:`RID<class_RID>`, enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_region_set_use_edge_connections>`
Se ``enabled`` è ``true``, la regione di navigazione ``region`` utilizzerà connessioni ai bordi per collegarsi con altre regioni di navigazione in prossimità del margine di connessione ai bordi della mappa di navigazione.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_set_active:
.. rst-class:: classref-method
|void| **set_active**\ (\ active\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_set_active>`
Controlla l'attivazione di questo server.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_set_debug_enabled:
.. rst-class:: classref-method
|void| **set_debug_enabled**\ (\ enabled\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_NavigationServer3D_method_set_debug_enabled>`
Se ``true`` abilita la modalità di debug sul NavigationServer.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_simplify_path:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **simplify_path**\ (\ path\: :ref:`PackedVector3Array<class_PackedVector3Array>`, epsilon\: :ref:`float<class_float>`\ ) :ref:`🔗<class_NavigationServer3D_method_simplify_path>`
Restituisce una versione semplificata del percorso ``path``, con punti meno critici del percorso rimossi. La quantità di semplificazione è controllata da ``epsilon``. La semplificazione utilizza una variazione dell'algoritmo Ramer-Douglas-Peucker per decimare i punti della curva.
La semplificazione del percorso può essere utile per mitigare vari problemi di seguimento del percorso che possono sorgere con certi tipi di agenti e comportamenti di script. Ad esempio, agenti che "sterzano" o evasione in "campi aperti".
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_source_geometry_parser_create:
.. rst-class:: classref-method
:ref:`RID<class_RID>` **source_geometry_parser_create**\ (\ ) :ref:`🔗<class_NavigationServer3D_method_source_geometry_parser_create>`
Crea un nuovo parser di geometria sorgente. Se un :ref:`Callable<class_Callable>` è impostato per il parser con :ref:`source_geometry_parser_set_callback()<class_NavigationServer3D_method_source_geometry_parser_set_callback>`, il callback verrà chiamato per ogni singolo nodo che viene analizzato, ogni volta che :ref:`parse_source_geometry_data()<class_NavigationServer3D_method_parse_source_geometry_data>` viene utilizzato.
.. rst-class:: classref-item-separator
----
.. _class_NavigationServer3D_method_source_geometry_parser_set_callback:
.. rst-class:: classref-method
|void| **source_geometry_parser_set_callback**\ (\ parser\: :ref:`RID<class_RID>`, callback\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_NavigationServer3D_method_source_geometry_parser_set_callback>`
Imposta il :ref:`Callable<class_Callable>` ``callback`` per il parser della geometria sorgente specifico da ``parser``. Il :ref:`Callable<class_Callable>` riceverà una chiamata con i seguenti parametri:
- ``navigation_mesh`` - Il riferimento :ref:`NavigationMesh<class_NavigationMesh>` utilizzato per definire la configurazione dell'analisi. NON modificarlo o aggiungerlo direttamente alla mesh di navigazione.
- ``source_geometry_data`` - Il riferimento :ref:`NavigationMeshSourceGeometryData2D<class_NavigationMeshSourceGeometryData2D>`. Aggiungi una geometria sorgente personalizzata per la preparazione della mesh di navigazione a questo oggetto.
- ``node`` - Il :ref:`Node<class_Node>` che è analizzato.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink