NavigationServer3D
Experimental: This class may be changed or removed in future versions.
Hereda: Object
Una interfaz de servidor para el acceso de navegación 3D de bajo nivel.
Descripción
NavigationServer3D is the server that handles navigation maps, regions and agents. It does not handle A* navigation from AStar3D.
Maps are divided into regions, which are composed of navigation meshes. Together, they define the navigable areas in the 3D world.
Note: Most NavigationServer3D changes take effect after the next physics frame and not immediately. This includes all changes made to maps, regions or agents by navigation-related nodes in the scene tree or made through scripts.
For two regions to be connected to each other, they must share a similar edge. An edge is considered connected to another if both of its two vertices are at a distance less than edge_connection_margin to the respective other edge's vertex.
You may assign navigation layers to regions with region_set_navigation_layers(), which then can be checked upon when requesting a path with map_get_path(). This can be used to allow or deny certain areas for some objects.
To use the collision avoidance system, you may use agents. You can set an agent's target velocity, then the servers will emit a callback with a modified velocity.
Note: The collision avoidance system ignores regions. Using the modified velocity directly may move an agent outside of the traversable area. This is a limitation of the collision avoidance system, any more complex situation may require the use of the physics engine.
This server keeps tracks of any call and executes them during the sync phase. This means that you can request any change to the map, using any thread, without worrying.
Tutoriales
Métodos
Señales
avoidance_debug_changed() 🔗
Se emite cuando se cambian los ajustes de depuración de la evitación. Solo disponible en compilaciones de depuración.
Se emite cuando se actualiza un mapa de navegación, cuando una región se mueve o se modifica.
navigation_debug_changed() 🔗
Se emite cuando se cambian los ajustes de depuración de la navegación. Solo disponible en compilaciones de depuración.
Enumeraciones
enum ProcessInfo: 🔗
ProcessInfo INFO_ACTIVE_MAPS = 0
Constante para obtener el número de mapas de navegación activos.
ProcessInfo INFO_REGION_COUNT = 1
Constante para obtener el número de regiones de navegación activas.
ProcessInfo INFO_AGENT_COUNT = 2
Constante para obtener el número de agentes de navegación activos que procesan la evitación.
ProcessInfo INFO_LINK_COUNT = 3
Constante para obtener el número de enlaces de navegación activos.
ProcessInfo INFO_POLYGON_COUNT = 4
Constante para obtener el número de polígonos de malla de navegación.
ProcessInfo INFO_EDGE_COUNT = 5
Constante para obtener el número de bordes de polígono de malla de navegación.
ProcessInfo INFO_EDGE_MERGE_COUNT = 6
Constante para obtener el número de bordes de polígono de la malla de navegación que se fusionaron debido a la superposición de claves de borde.
ProcessInfo INFO_EDGE_CONNECTION_COUNT = 7
Constante para obtener el número de bordes de polígono de la malla de navegación que se consideran conectados por proximidad de borde.
ProcessInfo INFO_EDGE_FREE_COUNT = 8
Constante para obtener el número de bordes de polígono de la malla de navegación que no se pudieron fusionar, pero que aún pueden estar conectados por proximidad de borde o con enlaces.
ProcessInfo INFO_OBSTACLE_COUNT = 9
Constante para obtener el número de obstáculos de navegación activos.
Descripciones de Métodos
Crea el agente.
bool agent_get_avoidance_enabled(agent: RID) const 🔗
Devuelve true si el agent proporcionado tiene la evitación habilitada.
int agent_get_avoidance_layers(agent: RID) const 🔗
Devuelve la máscara de bits de avoidance_layers del agent especificado.
int agent_get_avoidance_mask(agent: RID) const 🔗
Devuelve la máscara de bits de avoidance_mask del agent especificado.
float agent_get_avoidance_priority(agent: RID) const 🔗
Devuelve la avoidance_priority del agent especificado.
float agent_get_height(agent: RID) const 🔗
Devuelve la height del agent especificado.
RID agent_get_map(agent: RID) const 🔗
Devuelve el mapa de navegación RID al que está asignado actualmente el agent solicitado.
int agent_get_max_neighbors(agent: RID) const 🔗
Devuelve el número máximo de otros agentes que el agent especificado tiene en cuenta en la navegación.
float agent_get_max_speed(agent: RID) const 🔗
Devuelve la velocidad máxima del agent especificado.
float agent_get_neighbor_distance(agent: RID) const 🔗
Devuelve la distancia máxima a otros agentes que el agent especificado tiene en cuenta en la navegación.
bool agent_get_paused(agent: RID) const 🔗
Devuelve true si el agent especificado está en pausa.
Vector3 agent_get_position(agent: RID) const 🔗
Devuelve la posición del agent especificado en el espacio global.
float agent_get_radius(agent: RID) const 🔗
Devuelve el radio del agent especificado.
float agent_get_time_horizon_agents(agent: RID) const 🔗
Devuelve la cantidad mínima de tiempo durante la cual las velocidades del agent especificado que son calculadas por la simulación son seguras con respecto a otros agentes.
float agent_get_time_horizon_obstacles(agent: RID) const 🔗
Devuelve la cantidad mínima de tiempo durante la cual las velocidades del agent especificado que son calculadas por la simulación son seguras con respecto a los obstáculos estáticos de evitación.
bool agent_get_use_3d_avoidance(agent: RID) const 🔗
Devuelve true si el agent proporcionado utiliza la evitación en el espacio 3D Vector3(x,y,z) en lugar del Vector2(x,y) / Vector3(x,0.0,z) horizontal 2D.
Vector3 agent_get_velocity(agent: RID) const 🔗
Devuelve la velocidad del agent especificado.
bool agent_has_avoidance_callback(agent: RID) const 🔗
Return true if the specified agent has an avoidance callback.
bool agent_is_map_changed(agent: RID) const 🔗
Devuelve true si el mapa cambió en el fotograma anterior.
void agent_set_avoidance_callback(agent: RID, callback: Callable) 🔗
Sets the callback Callable that gets called after each avoidance processing step for the agent. The calculated safe_velocity will be dispatched with a signal to the object just before the physics calculations.
Note: Created callbacks are always processed independently of the SceneTree state as long as the agent is on a navigation map and not freed. To disable the dispatch of a callback from an agent use agent_set_avoidance_callback() again with an empty Callable.
void agent_set_avoidance_enabled(agent: RID, enabled: bool) 🔗
Si enabled es true, el agent proporcionado calcula la evitación.
void agent_set_avoidance_layers(agent: RID, layers: int) 🔗
Establece la máscara de bits avoidance_layers del agente.
void agent_set_avoidance_mask(agent: RID, mask: int) 🔗
Establece la máscara de bits avoidance_mask del agente.
void agent_set_avoidance_priority(agent: RID, priority: float) 🔗
Establece la avoidance_priority del agente con una priority entre 0.0 (prioridad más baja) y 1.0 (prioridad más alta).
El agent especificado no ajusta la velocidad para otros agentes que coincidan con la avoidance_mask pero que tengan una avoidance_priority más baja. Esto a su vez hace que los otros agentes con menor prioridad ajusten aún más sus velocidades para evitar la colisión con este agente.
void agent_set_height(agent: RID, height: float) 🔗
Actualiza la height del agent proporcionado.
void agent_set_map(agent: RID, map: RID) 🔗
Pone al agente en el mapa.
void agent_set_max_neighbors(agent: RID, count: int) 🔗
Establece el número máximo de otros agentes que el agente tiene en cuenta en la navegación. Cuanto mayor sea este número, mayor será el tiempo de ejecución de la simulación. Si el número es demasiado bajo, la simulación no será segura.
void agent_set_max_speed(agent: RID, max_speed: float) 🔗
Establece la velocidad máxima del agente. Debe ser positiva.
void agent_set_neighbor_distance(agent: RID, distance: float) 🔗
Establece la distancia máxima a otros agentes que este agente tiene en cuenta en la navegación. Cuanto mayor sea este número, mayor será el tiempo de ejecución de la simulación. Si el número es demasiado bajo, la simulación no será segura.
void agent_set_paused(agent: RID, paused: bool) 🔗
If paused is true the specified agent will not be processed. For example, it will not calculate avoidance velocities or receive avoidance callbacks.
void agent_set_position(agent: RID, position: Vector3) 🔗
Establece la posición del agente en el espacio mundial.
void agent_set_radius(agent: RID, radius: float) 🔗
Establece el radio del agente.
void agent_set_time_horizon_agents(agent: RID, time_horizon: float) 🔗
La cantidad mínima de tiempo durante la cual las velocidades del agente que son calculadas por la simulación son seguras con respecto a otros agentes. Cuanto mayor sea este número, antes responderá este agente a la presencia de otros agentes, pero menos libertad tendrá este agente para elegir sus velocidades. Un valor demasiado alto ralentizará considerablemente el movimiento de los agentes. Debe ser positivo.
void agent_set_time_horizon_obstacles(agent: RID, time_horizon: float) 🔗
La cantidad mínima de tiempo durante la cual las velocidades del agente que son calculadas por la simulación son seguras con respecto a los obstáculos estáticos de evitación. Cuanto mayor sea este número, antes responderá este agente a la presencia de obstáculos estáticos de evitación, pero menos libertad tendrá este agente para elegir sus velocidades. Un valor demasiado alto ralentizará considerablemente el movimiento de los agentes. Debe ser positivo.
void agent_set_use_3d_avoidance(agent: RID, enabled: bool) 🔗
Establece si el agente usa la evitación 2D o la evitación 3D mientras la evitación está habilitada.
Si es true, el agente calcula las velocidades de evitación en 3D para el eje xyz, p. ej., para juegos que tienen lugar en el aire, bajo el agua o en el espacio. El agente que usa 3D solo evita a otros agentes que usan la evitación 3D. El agente que usa 3D solo reacciona a los obstáculos de evitación basados en el radio. El agente que usa 3D ignora cualquier obstáculo basado en vértices. El agente que usa 3D solo evita a otros agentes que usan 3D.
Si es false, el agente calcula las velocidades de evitación en 2D a lo largo del eje xz ignorando el eje y. El agente que usa 2D solo evita a otros agentes que usan la evitación 2D. El agente que usa 2D reacciona a los obstáculos de evitación basados en el radio. El agente que usa 2D reacciona a los obstáculos basados en vértices. El agente que usa 2D solo evita a otros agentes que usan 2D. Los agentes que usan 2D ignorarán a otros agentes u obstáculos que estén por debajo de su posición actual o por encima de su posición actual, incluida la altura de los agentes en la evitación 2D.
void agent_set_velocity(agent: RID, velocity: Vector3) 🔗
Establece velocity como la nueva velocidad deseada para el agent especificado. La simulación de evitación intentará cumplir con esta velocidad si es posible, pero la modificará para evitar la colisión con otros agentes y obstáculos. Cuando un agente es teletransportado a una nueva posición, use también agent_set_velocity_forced() para restablecer la velocidad de simulación interna.
void agent_set_velocity_forced(agent: RID, velocity: Vector3) 🔗
Reemplaza la velocidad interna en la simulación de evitación de colisiones con velocity para el agent especificado. Cuando un agente es teletransportado a una nueva posición, esta función debe usarse en el mismo fotograma. Si se llama con frecuencia, esta función puede atascar a los agentes.
void bake_from_source_geometry_data(navigation_mesh: NavigationMesh, source_geometry_data: NavigationMeshSourceGeometryData3D, callback: Callable = Callable()) 🔗
Procesa la navigation_mesh proporcionada con los datos del source_geometry_data proporcionado. Una vez que finalice el proceso, se llamará al callback opcional.
void bake_from_source_geometry_data_async(navigation_mesh: NavigationMesh, source_geometry_data: NavigationMeshSourceGeometryData3D, callback: Callable = Callable()) 🔗
Procesa la navigation_mesh proporcionada con los datos de la source_geometry_data proporcionada como una tarea asíncrona que se ejecuta en un hilo en segundo plano. Una vez finalizado el proceso, se llamará a la callback opcional.
Destruye el RID dado.
bool get_debug_enabled() const 🔗
Devuelve true cuando NavigationServer tiene habilitada la depuración.
Devuelve todos los RID del mapa de navegación creados en el NavigationServer. Esto devuelve los mapas de navegación 2D y 3D creados, ya que técnicamente no hay distinción entre ellos.
int get_process_info(process_info: ProcessInfo) const 🔗
Devuelve información sobre el estado actual del NavigationServer.
bool is_baking_navigation_mesh(navigation_mesh: NavigationMesh) const 🔗
Devuelve true cuando la malla de navegación proporcionada se está procesando en un hilo en segundo plano.
Crea un nuevo enlace entre dos posiciones en un mapa.
bool link_get_enabled(link: RID) const 🔗
Devuelve true si el link especificado está habilitado.
Vector3 link_get_end_position(link: RID) const 🔗
Devuelve la posición final de este link.
float link_get_enter_cost(link: RID) const 🔗
Devuelve el costo de entrada de este link.
int link_get_iteration_id(link: RID) const 🔗
Devuelve el ID de iteración actual del enlace de navegación. Cada vez que el enlace de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de 0 significa que el enlace de navegación nunca se ha sincronizado.
Nota: El ID de iteración volverá a 1 después de alcanzar su límite de rango.
RID link_get_map(link: RID) const 🔗
Devuelve el mapa de navegación RID al que está asignado actualmente el link solicitado.
int link_get_navigation_layers(link: RID) const 🔗
Devuelve las capas de navegación para este link.
int link_get_owner_id(link: RID) const 🔗
Devuelve el ObjectID del objeto que administra este vínculo.
Vector3 link_get_start_position(link: RID) const 🔗
Devuelve la posición inicial de este link.
float link_get_travel_cost(link: RID) const 🔗
Devuelve el costo del viaje de este link.
bool link_is_bidirectional(link: RID) const 🔗
Devuelve si este link se puede recorrer en ambas direcciones.
void link_set_bidirectional(link: RID, bidirectional: bool) 🔗
Establece si este link se puede recorrer en ambas direcciones.
void link_set_enabled(link: RID, enabled: bool) 🔗
Si enabled es true, el link especificado contribuirá a su mapa de navegación actual.
void link_set_end_position(link: RID, position: Vector3) 🔗
Establece la posición de salida para el link.
void link_set_enter_cost(link: RID, enter_cost: float) 🔗
Establece el enter_cost para este link.
void link_set_map(link: RID, map: RID) 🔗
Establece el RID del mapa de navegación para el enlace.
void link_set_navigation_layers(link: RID, navigation_layers: int) 🔗
Establece las capas de navegación de los enlaces. Esto permite seleccionar enlaces de una solicitud de ruta (cuando se usa map_get_path()).
void link_set_owner_id(link: RID, owner_id: int) 🔗
Establece el ObjectID del objeto que gestiona este enlace.
void link_set_start_position(link: RID, position: Vector3) 🔗
Establece la posición de entrada para este link.
void link_set_travel_cost(link: RID, travel_cost: float) 🔗
Establece el travel_cost para este link.
Crea un nuevo mapa.
void map_force_update(map: RID) 🔗
Obsoleto: 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.
Esta función fuerza inmediatamente la sincronización del map de navegación especificado RID. Por defecto, los mapas de navegación solo se sincronizan al final de cada fotograma de física. Esta función se puede utilizar para (re)calcular inmediatamente todas las mallas de navegación y las conexiones de región del mapa de navegación. Esto permite consultar un camino de navegación para un mapa cambiado inmediatamente y en el mismo fotograma (varias veces si es necesario).
Debido a restricciones técnicas, la cola de comandos actual de NavigationServer se vaciará. Esto significa que todos los comandos de actualización ya en cola para este fotograma de física se ejecutarán, incluso aquellos destinados a otros mapas, regiones y agentes que no forman parte del mapa especificado. El costoso cálculo de las mallas de navegación y las conexiones de región de un mapa solo se realizará para el mapa especificado. Otros mapas recibirán la sincronización normal al final del fotograma de física. Si el mapa especificado recibe cambios después de la actualización forzada, también se actualizará de nuevo cuando los otros mapas reciban su actualización.
El procesamiento de evitación y el envío de las señales de safe_velocity no se ven afectados por esta función y continúan ocurriendo para todos los mapas y agentes al final del fotograma de física.
Nota: Un gran poder conlleva una gran responsabilidad. Esta función solo debe ser utilizada por usuarios que realmente sepan lo que están haciendo y tengan una buena razón para ello. Forzar una actualización inmediata de un mapa de navegación requiere bloquear el NavigationServer y vaciar toda la cola de comandos del NavigationServer. Esto no solo puede afectar gravemente al rendimiento de un juego, sino que también puede introducir errores si se utiliza de forma inapropiada sin mucha previsión.
Array[RID] map_get_agents(map: RID) const 🔗
Devuelve todos los RID de agentes de navegación que están actualmente asignados al map de navegación solicitado.
float map_get_cell_height(map: RID) const 🔗
Devuelve la altura de la celda del mapa utilizada para rasterizar los vértices de la malla de navegación en el eje Y.
float map_get_cell_size(map: RID) const 🔗
Devuelve el tamaño de la celda del mapa utilizada para rasterizar los vértices de la malla de navegación en el plano XZ.
Vector3 map_get_closest_point(map: RID, to_point: Vector3) const 🔗
Devuelve el punto de la superficie de la malla de navegación más cercano al to_point proporcionado en el map de navegación.
Vector3 map_get_closest_point_normal(map: RID, to_point: Vector3) const 🔗
Devuelve la normal de la superficie de la malla de navegación más cercana al to_point proporcionado en el map de navegación.
RID map_get_closest_point_owner(map: RID, to_point: Vector3) const 🔗
Devuelve el RID de la región propietaria del punto de la superficie de la malla de navegación más cercano al to_point proporcionado en el map de navegación.
Vector3 map_get_closest_point_to_segment(map: RID, start: Vector3, end: Vector3, use_collision: bool = false) const 🔗
Devuelve el punto de la superficie de la malla de navegación más cercano al segmento start y end proporcionado en el map de navegación.
Si use_collision es true, solo se realiza una prueba del punto más cercano cuando el segmento se cruza con la superficie de la malla de navegación.
float map_get_edge_connection_margin(map: RID) const 🔗
Devuelve el margen de conexión de bordes del mapa. Esta distancia es la distancia mínima entre vértices necesaria para conectar dos bordes de diferentes regiones.
int map_get_iteration_id(map: RID) const 🔗
Devuelve el ID de iteración actual del mapa de navegación. Cada vez que el mapa de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de 0 significa que el mapa de navegación nunca se ha sincronizado.
Nota: El ID de iteración volverá a 1 después de alcanzar el límite de su rango.
float map_get_link_connection_radius(map: RID) const 🔗
Devuelve el radio de conexión del enlace del mapa. Esta distancia es el alcance máximo que cualquier enlace buscará para los polígonos de la malla de navegación a los que conectarse.
Array[RID] map_get_links(map: RID) const 🔗
Devuelve todos los RID de enlaces de navegación que están actualmente asignados al map de navegación solicitado.
float map_get_merge_rasterizer_cell_scale(map: RID) const 🔗
Devuelve la escala de celda interna del rasterizador de fusión del mapa.
Array[RID] map_get_obstacles(map: RID) const 🔗
Devuelve todos los RID de obstáculos de navegación que están actualmente asignados al map de navegación solicitado.
PackedVector3Array map_get_path(map: RID, origin: Vector3, destination: Vector3, optimize: bool, navigation_layers: int = 1) 🔗
Devuelve la ruta de navegación para alcanzar el destino desde el origen. navigation_layers es una máscara de bits de todas las capas de navegación de la región que pueden estar en la ruta.
Vector3 map_get_random_point(map: RID, navigation_layers: int, uniformly: bool) const 🔗
Devuelve una posición aleatoria seleccionada de todos los polígonos de la región del mapa que coincidan con navigation_layers.
Si uniformly es true, todas las regiones del mapa, los polígonos y las caras se ponderan por su área de superficie (más lento).
Si uniformly es false, solo se elige una región aleatoria y un polígono aleatorio (más rápido).
Array[RID] map_get_regions(map: RID) const 🔗
Devuelve todos los RID de las regiones de navegación que están actualmente asignadas al map de navegación solicitado.
Vector3 map_get_up(map: RID) const 🔗
Devuelve la dirección hacia arriba del mapa.
bool map_get_use_async_iterations(map: RID) const 🔗
Devuelve true si la sincronización del map utiliza un proceso asíncrono que se ejecuta en un hilo en segundo plano.
bool map_get_use_edge_connections(map: RID) const 🔗
Devuelve true si el map de navegación permite que las regiones de navegación utilicen conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
bool map_is_active(map: RID) const 🔗
Devuelve true si el mapa está activo.
void map_set_active(map: RID, active: bool) 🔗
Establece el mapa como activo.
void map_set_cell_height(map: RID, cell_height: float) 🔗
Establece la altura de celda del mapa utilizada para rasterizar los vértices de la malla de navegación en el eje Y. Debe coincidir con la altura de celda de las mallas de navegación utilizadas.
void map_set_cell_size(map: RID, cell_size: float) 🔗
Establece el tamaño de celda del mapa utilizado para rasterizar los vértices de la malla de navegación en el plano XZ. Debe coincidir con el tamaño de celda de las mallas de navegación utilizadas.
void map_set_edge_connection_margin(map: RID, margin: float) 🔗
Establece el margen de conexión de borde del mapa utilizado para soldar los bordes de región compatibles.
void map_set_link_connection_radius(map: RID, radius: float) 🔗
Establece el radio de conexión del enlace del mapa utilizado para conectar los enlaces a los polígonos de navegación.
void map_set_merge_rasterizer_cell_scale(map: RID, scale: float) 🔗
Establece la escala de celda interna del rasterizador de fusión del mapa utilizada para controlar la sensibilidad de la fusión.
void map_set_up(map: RID, up: Vector3) 🔗
Establece la dirección del mapa.
void map_set_use_async_iterations(map: RID, enabled: bool) 🔗
Si enabled es true, la sincronización del map utiliza un proceso asíncrono que se ejecuta en un hilo en segundo plano.
void map_set_use_edge_connections(map: RID, enabled: bool) 🔗
Establece el uso de la conexión de borde del map de navegación. Si enabled es true, el mapa de navegación permite que las regiones de navegación utilicen conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
Crea un nuevo obstáculo.
bool obstacle_get_avoidance_enabled(obstacle: RID) const 🔗
Devuelve true si el obstacle proporcionado tiene la evitación habilitada.
int obstacle_get_avoidance_layers(obstacle: RID) const 🔗
Devuelve la máscara de bits de avoidance_layers del obstacle especificado.
float obstacle_get_height(obstacle: RID) const 🔗
Devuelve la height del obstacle especificado.
RID obstacle_get_map(obstacle: RID) const 🔗
Devuelve el RID del mapa de navegación al que está asignado actualmente el obstacle solicitado.
bool obstacle_get_paused(obstacle: RID) const 🔗
Devuelve true si el obstacle especificado está en pausa.
Vector3 obstacle_get_position(obstacle: RID) const 🔗
Devuelve la posición del obstacle especificado en el espacio mundial.
float obstacle_get_radius(obstacle: RID) const 🔗
Devuelve el radio del obstacle dinámico especificado.
bool obstacle_get_use_3d_avoidance(obstacle: RID) const 🔗
Devuelve true si el obstacle proporcionado utiliza la evitación en el espacio 3D Vector3(x,y,z) en lugar del Vector2(x,y) / Vector3(x,0.0,z) horizontal 2D.
Vector3 obstacle_get_velocity(obstacle: RID) const 🔗
Devuelve la velocidad del obstacle dinámico especificado.
PackedVector3Array obstacle_get_vertices(obstacle: RID) const 🔗
Devuelve los vértices del contorno para el obstacle especificado.
void obstacle_set_avoidance_enabled(obstacle: RID, enabled: bool) 🔗
Si enabled es true, el obstacle proporcionado afecta la evitación usando agentes.
void obstacle_set_avoidance_layers(obstacle: RID, layers: int) 🔗
Establece la máscara de bits avoidance_layers del obstáculo.
void obstacle_set_height(obstacle: RID, height: float) 🔗
Establece la height para el obstacle. En 3D, los agentes ignorarán los obstáculos que estén por encima o por debajo de ellos mientras usan la evitación 2D.
void obstacle_set_map(obstacle: RID, map: RID) 🔗
Asigna el obstacle a un mapa de navegación.
void obstacle_set_paused(obstacle: RID, paused: bool) 🔗
Si paused es true, el obstacle especificado no se procesará. Por ejemplo, ya no afectará las velocidades de evitación.
void obstacle_set_position(obstacle: RID, position: Vector3) 🔗
Actualiza la position en el espacio mundial para el obstacle.
void obstacle_set_radius(obstacle: RID, radius: float) 🔗
Establece el radio del obstáculo dinámico.
void obstacle_set_use_3d_avoidance(obstacle: RID, enabled: bool) 🔗
Establece si el obstacle utiliza la evitación 2D o la evitación 3D mientras la evitación está habilitada.
void obstacle_set_velocity(obstacle: RID, velocity: Vector3) 🔗
Establece velocity del obstacle dinámico. Permite que otros agentes predigan mejor el movimiento del obstáculo dinámico. Solo funciona en combinación con el radio del obstáculo.
void obstacle_set_vertices(obstacle: RID, vertices: PackedVector3Array) 🔗
Establece los vértices del contorno para el obstáculo. Si los vértices se enrollan en el sentido de las agujas del reloj, los agentes serán empujados hacia adentro por el obstáculo, de lo contrario, serán empujados hacia afuera.
void parse_source_geometry_data(navigation_mesh: NavigationMesh, source_geometry_data: NavigationMeshSourceGeometryData3D, root_node: Node, callback: Callable = Callable()) 🔗
Parses the SceneTree for source geometry according to the properties of navigation_mesh. Updates the provided source_geometry_data resource with the resulting data. The resource can then be used to bake a navigation mesh with bake_from_source_geometry_data(). After the process is finished the optional callback will be called.
Note: This function needs to run on the main thread or with a deferred call as the SceneTree is not thread-safe.
Performance: While convenient, reading data arrays from Mesh resources can affect the frame rate negatively. The data needs to be received from the GPU, stalling the RenderingServer in the process. For performance prefer the use of e.g. collision shapes or creating the data arrays entirely in code.
void query_path(parameters: NavigationPathQueryParameters3D, result: NavigationPathQueryResult3D, callback: Callable = Callable()) 🔗
Consulta una ruta en un mapa de navegación dado. La posición de inicio y de destino y otros parámetros se definen a través de NavigationPathQueryParameters3D. Actualiza el objeto de resultado NavigationPathQueryResult3D proporcionado con la ruta entre otros resultados solicitados por la consulta. Una vez finalizado el proceso, se llamará al callback opcional.
void region_bake_navigation_mesh(navigation_mesh: NavigationMesh, root_node: Node) 🔗
Obsoleto: This method is deprecated due to core threading changes. To upgrade existing code, first create a NavigationMeshSourceGeometryData3D resource. Use this resource with parse_source_geometry_data() to parse the SceneTree for nodes that should contribute to the navigation mesh baking. The SceneTree parsing needs to happen on the main thread. After the parsing is finished use the resource with bake_from_source_geometry_data() to bake a navigation mesh.
Procesa la navigation_mesh con la geometría de origen de procesado recogida a partir del root_node.
Crea una nueva región.
AABB region_get_bounds(region: RID) const 🔗
Devuelve el cuadro delimitador alineado con el eje para la malla de navegación transformada del region.
Vector3 region_get_closest_point(region: RID, to_point: Vector3) const 🔗
Devuelve el punto de la superficie de la malla de navegación más cercano al to_point proporcionado en la region de navegación.
Vector3 region_get_closest_point_normal(region: RID, to_point: Vector3) const 🔗
Devuelve la normal de la superficie de la malla de navegación más cercana al to_point proporcionado en la region de navegación.
Vector3 region_get_closest_point_to_segment(region: RID, start: Vector3, end: Vector3, use_collision: bool = false) const 🔗
Devuelve el punto de la superficie de la malla de navegación más cercano al segmento start y end proporcionado en la region de navegación.
Si use_collision es true, solo se realiza una prueba del punto más cercano cuando el segmento se cruza con la superficie de la malla de navegación.
Vector3 region_get_connection_pathway_end(region: RID, connection: int) const 🔗
Devuelve el punto final de una puerta de conexión. connection es un índice entre 0 y el valor de retorno de region_get_connections_count().
Vector3 region_get_connection_pathway_start(region: RID, connection: int) const 🔗
Devuelve el punto de inicio de una puerta de conexión. connection es un índice entre 0 y el valor de retorno de region_get_connections_count().
int region_get_connections_count(region: RID) const 🔗
Devuelve cuántas conexiones tiene esta region con otras regiones en el mapa.
bool region_get_enabled(region: RID) const 🔗
Devuelve true si la region especificada está habilitada.
float region_get_enter_cost(region: RID) const 🔗
Devuelve el costo de entrada de esta region.
int region_get_iteration_id(region: RID) const 🔗
Devuelve el ID de iteración actual de la región de navegación. Cada vez que la región de navegación cambia y se sincroniza, el ID de iteración aumenta. Un ID de iteración de 0 significa que la región de navegación nunca se ha sincronizado.
Nota: El ID de iteración volverá a 1 después de alcanzar su límite de rango.
RID region_get_map(region: RID) const 🔗
Devuelve el mapa de navegación RID al que está asignada actualmente la region solicitada.
int region_get_navigation_layers(region: RID) const 🔗
Devuelve las capas de navegación de la región.
int region_get_owner_id(region: RID) const 🔗
Devuelve el ObjectID del objeto que gestiona esta región.
Vector3 region_get_random_point(region: RID, navigation_layers: int, uniformly: bool) const 🔗
Devuelve una posición aleatoria seleccionada de todos los polígonos de la región que coinciden con navigation_layers.
Si uniformly es true, todos los polígonos y caras de la región se ponderan por su área de superficie (más lento).
Si uniformly es false, solo se elige un polígono y una cara aleatorios (más rápido).
Transform3D region_get_transform(region: RID) const 🔗
Devuelve la transformación global de esta region.
float region_get_travel_cost(region: RID) const 🔗
Devuelve el costo de viaje de esta region.
bool region_get_use_async_iterations(region: RID) const 🔗
Devuelve true si la region utiliza un proceso de sincronización asíncrono que se ejecuta en un hilo secundario.
bool region_get_use_edge_connections(region: RID) const 🔗
Devuelve true si la region de navegación está configurada para usar conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
bool region_owns_point(region: RID, point: Vector3) const 🔗
Returns true if the provided point in world space is currently owned by the provided navigation region. Owned in this context means that one of the region's navigation mesh polygon faces has a possible position at the closest distance to this point compared to all other navigation meshes from other navigation regions that are also registered on the navigation map of the provided region.
If multiple navigation meshes have positions at equal distance the navigation region whose polygons are processed first wins the ownership. Polygons are processed in the same order that navigation regions were registered on the NavigationServer.
Note: If navigation meshes from different navigation regions overlap (which should be avoided in general) the result might not be what is expected.
void region_set_enabled(region: RID, enabled: bool) 🔗
Si enabled es true, la region especificada contribuirá a su mapa de navegación actual.
void region_set_enter_cost(region: RID, enter_cost: float) 🔗
Establece el enter_cost para esta region.
void region_set_map(region: RID, map: RID) 🔗
Establece el mapa para la región.
void region_set_navigation_layers(region: RID, navigation_layers: int) 🔗
Establece las capas de navegación de la región. Esto permite seleccionar regiones de una solicitud de ruta (cuando se usa map_get_path()).
void region_set_navigation_mesh(region: RID, navigation_mesh: NavigationMesh) 🔗
Establece la malla de navegación para la región.
void region_set_owner_id(region: RID, owner_id: int) 🔗
Establece el ObjectID del objeto que gestiona esta región.
void region_set_transform(region: RID, transform: Transform3D) 🔗
Establece la transformación global para la región.
void region_set_travel_cost(region: RID, travel_cost: float) 🔗
Establece el travel_cost para esta region.
void region_set_use_async_iterations(region: RID, enabled: bool) 🔗
Si enabled es true, la region utiliza un proceso de sincronización asíncrono que se ejecuta en un hilo secundario.
void region_set_use_edge_connections(region: RID, enabled: bool) 🔗
Si enabled es true, la region de navegación utilizará conexiones de borde para conectarse con otras regiones de navegación dentro de la proximidad del margen de conexión de borde del mapa de navegación.
void set_active(active: bool) 🔗
Controlar la activación de este servidor.
void set_debug_enabled(enabled: bool) 🔗
Si es true, habilita el modo de depuración en NavigationServer.
PackedVector3Array simplify_path(path: PackedVector3Array, epsilon: float) 🔗
Devuelve una versión simplificada de path con menos puntos de ruta críticos eliminados. La cantidad de simplificación está en unidades del mundo y está controlada por epsilon. La simplificación utiliza una variante del algoritmo de Ramer-Douglas-Peucker para la decimación de puntos de curva.
La simplificación de la ruta puede ser útil para mitigar varios problemas de seguimiento de la ruta que pueden surgir con ciertos tipos de agentes y comportamientos de script. P.ej. agentes de "dirección" o evitación en "campos abiertos".
RID source_geometry_parser_create() 🔗
Crea un nuevo analizador de geometría de origen. Si se establece un Callable para el analizador con source_geometry_parser_set_callback(), se llamará al callback para cada nodo que se analice siempre que se utilice parse_source_geometry_data().
void source_geometry_parser_set_callback(parser: RID, callback: Callable) 🔗
Sets the callback Callable for the specific source geometry parser. The Callable will receive a call with the following parameters:
navigation_mesh- The NavigationMesh reference used to define the parse settings. Do NOT edit or add directly to the navigation mesh.source_geometry_data- The NavigationMeshSourceGeometryData3D reference. Add custom source geometry for navigation mesh baking to this object.node- The Node that is parsed.