NavigationMesh

Sperimentale: This class may be changed or removed in future versions.

Eredita: Resource < RefCounted < Object

Una mesh di navigazione che definisce le aree attraversabili e gli ostacoli.

Descrizione

Una mesh di navigazione è una collezione di poligoni che definiscono quali aree di un ambiente sono attraversabili per aiutare gli agenti a trovare il percorso attraverso spazi complicati.

Tutorial

Proprietà

float	agent_height	`1.5`
float	agent_max_climb	`0.25`
float	agent_max_slope	`45.0`
float	agent_radius	`0.5`
float	border_size	`0.0`
float	cell_height	`0.25`
float	cell_size	`0.25`
float	detail_sample_distance	`6.0`
float	detail_sample_max_error	`1.0`
float	edge_max_error	`1.3`
float	edge_max_length	`0.0`
AABB	filter_baking_aabb	`AABB(0, 0, 0, 0, 0, 0)`
Vector3	filter_baking_aabb_offset	`Vector3(0, 0, 0)`
bool	filter_ledge_spans	`false`
bool	filter_low_hanging_obstacles	`false`
bool	filter_walkable_low_height_spans	`false`
int	geometry_collision_mask	`4294967295`
ParsedGeometryType	geometry_parsed_geometry_type	`2`
SourceGeometryMode	geometry_source_geometry_mode	`0`
StringName	geometry_source_group_name	`&"navigation_mesh_source_group"`
float	region_merge_size	`20.0`
float	region_min_size	`2.0`
SamplePartitionType	sample_partition_type	`0`
float	vertices_per_polygon	`6.0`

Metodi

void	add_polygon(polygon: PackedInt32Array)
void	clear()
void	clear_polygons()
void	create_from_mesh(mesh: Mesh)
bool	get_collision_mask_value(layer_number: int) const
PackedInt32Array	get_polygon(idx: int)
int	get_polygon_count() const
PackedVector3Array	get_vertices() const
void	set_collision_mask_value(layer_number: int, value: bool)
void	set_vertices(vertices: PackedVector3Array)

Enumerazioni

enum SamplePartitionType: 🔗

SamplePartitionType SAMPLE_PARTITION_WATERSHED = 0

Partizionamento spartiacque. In genere è la scelta migliore se si precalcola la mesh di navigazione, da usare se si hanno grandi aree aperte.

SamplePartitionType SAMPLE_PARTITION_MONOTONE = 1

Partizionamento monotono. Da usare se si desidera una generazione veloce della mesh di navigazione.

SamplePartitionType SAMPLE_PARTITION_LAYERS = 2

Partizionamento a livelli. Una buona scelta da usare per le mesh di navigazione con tessere di medie e piccole dimensioni.

SamplePartitionType SAMPLE_PARTITION_MAX = 3

Rappresenta la dimensione dell'enumerazione SamplePartitionType.

enum ParsedGeometryType: 🔗

ParsedGeometryType PARSED_GEOMETRY_MESH_INSTANCES = 0

Interpreta le istanze di mesh come geometria. Ciò include i nodi MeshInstance3D, CSGShape3D e GridMap.

ParsedGeometryType PARSED_GEOMETRY_STATIC_COLLIDERS = 1

Interpreta i collisori StaticBody3D come geometria. Il collisore deve trovarsi in uno qualsiasi degli strati specificati da geometry_collision_mask.

ParsedGeometryType PARSED_GEOMETRY_BOTH = 2

Sia PARSED_GEOMETRY_MESH_INSTANCES che PARSED_GEOMETRY_STATIC_COLLIDERS.

ParsedGeometryType PARSED_GEOMETRY_MAX = 3

Rappresenta la dimensione dell'enumerazione ParsedGeometryType.

enum SourceGeometryMode: 🔗

SourceGeometryMode SOURCE_GEOMETRY_ROOT_NODE_CHILDREN = 0

Scansiona ricorsivamente i nodi figlio del nodo radice per trovare la geometria.

SourceGeometryMode SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN = 1

Scansiona ricorsivamente i nodi in un gruppo e dei loro nodi figlio per trovare la geometria. Il gruppo è specificato da geometry_source_group_name.

SourceGeometryMode SOURCE_GEOMETRY_GROUPS_EXPLICIT = 2

Utilizza i nodi in un gruppo per la geometria. Il gruppo è specificato da geometry_source_group_name.

SourceGeometryMode SOURCE_GEOMETRY_MAX = 3

Rappresenta la dimensione dell'enumerazione SourceGeometryMode.

Descrizioni delle proprietà

float agent_height = 1.5 🔗

void set_agent_height(value: float)
float get_agent_height()

L'altezza minima tra pavimento e soffitto che consentirà comunque all'area del pavimento di essere considerata percorribile.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_height.

float agent_max_climb = 0.25 🔗

void set_agent_max_climb(value: float)
float get_agent_max_climb()

L'altezza minima di una sporgenza che è considerata ancora percorribile.

Nota: Durante la preparazione, questo valore sarà arrotondato per difetto al multiplo più vicino di cell_height.

float agent_max_slope = 45.0 🔗

void set_agent_max_slope(value: float)
float get_agent_max_slope()

La pendenza massima che è considerata percorribile, in gradi.

float agent_radius = 0.5 🔗

void set_agent_radius(value: float)
float get_agent_radius()

La distanza per erodere/restringere l'area percorribile del campo di altezza dagli ostacoli.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_size.

Nota: Il raggio deve essere uguale o superiore a 0.0. Se il raggio è 0.0, non sarà possibile correggere sovrapposizioni non valide tra contorni e altri errori di precisione durante il processo di preparazione. Di conseguenza, alcuni ostacoli potrebbero essere esclusi erroneamente dalla mesh di navigazione finale o potrebbero eliminare i poligoni della mesh di navigazione.

float border_size = 0.0 🔗

void set_border_size(value: float)
float get_border_size()

La dimensione del bordo non navigabile attorno all'area di delimitazione della preparazione.

In combinazione con filter_baking_aabb e un valore edge_max_error inferiore o uguale a 1.0, è possibile utilizzare la dimensione del bordo per preparare mesh di navigazione allineate ai tasselli senza che i bordi dei tasselli siano ridotti di agent_radius.

Nota: Se questo valore non è 0.0, sarà arrotondato al multiplo più vicino di cell_size durante la preparazione.

float cell_height = 0.25 🔗

void set_cell_height(value: float)
float get_cell_height()

L'altezza delle celle utilizzata per rasterizzare i vertici della mesh di navigazione sull'asse Y. Deve corrispondere all'altezza delle celle sulla mappa di navigazione.

float cell_size = 0.25 🔗

void set_cell_size(value: float)
float get_cell_size()

Le dimensioni delle celle utilizzate per rasterizzare i vertici della mesh di navigazione sul piano XZ. Deve corrispondere alle dimensioni delle celle sulla mappa di navigazione.

float detail_sample_distance = 6.0 🔗

void set_detail_sample_distance(value: float)
float get_detail_sample_distance()

La distanza di campionamento da utilizzare per generare la mesh di dettaglio, in unità di cella.

float detail_sample_max_error = 1.0 🔗

void set_detail_sample_max_error(value: float)
float get_detail_sample_max_error()

La distanza massima a cui la superficie della mesh di dettaglio deve deviare da campo d'altezza, in unità di cella.

float edge_max_error = 1.3 🔗

void set_edge_max_error(value: float)
float get_edge_max_error()

La distanza massima alla quale i bordi di un contorno semplificato devono deviare dal contorno grezzo originale.

float edge_max_length = 0.0 🔗

void set_edge_max_length(value: float)
float get_edge_max_length()

La lunghezza massima consentita per i bordi del contorno lungo il bordo della mesh. Un valore di 0.0 disabilita questa funzionalità.

Nota: Durante la preparazione, questo valore sarà arrotondato al multiplo più vicino di cell_size.

AABB filter_baking_aabb = AABB(0, 0, 0, 0, 0, 0) 🔗

void set_filter_baking_aabb(value: AABB)
AABB get_filter_baking_aabb()

Se l'elaborazione dell'AABB ha un volume, l'elaborazionedella mesh di navigazione sarà limitata all'area che la racchiude.

Vector3 filter_baking_aabb_offset = Vector3(0, 0, 0) 🔗

void set_filter_baking_aabb_offset(value: Vector3)
Vector3 get_filter_baking_aabb_offset()

L'offset di posizione applicato all'AABB filter_baking_aabb.

bool filter_ledge_spans = false 🔗

void set_filter_ledge_spans(value: bool)
bool get_filter_ledge_spans()

Se true, segna bordi che sono sporgenze come non camminabili.

bool filter_low_hanging_obstacles = false 🔗

void set_filter_low_hanging_obstacles(value: bool)
bool get_filter_low_hanging_obstacles()

Se true, contrassegna gli intervalli non percorribili come percorribili se il loro massimo è compreso entro agent_max_climb da un vicino percorribile.

bool filter_walkable_low_height_spans = false 🔗

void set_filter_walkable_low_height_spans(value: bool)
bool get_filter_walkable_low_height_spans()

Se true, contrassegna gli intervalli percorribili come non percorribili se lo spazio libero sopra l'intervallo è inferiore a agent_height.

int geometry_collision_mask = 4294967295 🔗

void set_collision_mask(value: int)
int get_collision_mask()

Gli strati di fisica da scansionare per i collisori statici.

Utilizzato solo quando geometry_parsed_geometry_type è PARSED_GEOMETRY_STATIC_COLLIDERS o PARSED_GEOMETRY_BOTH.

ParsedGeometryType geometry_parsed_geometry_type = 2 🔗

void set_parsed_geometry_type(value: ParsedGeometryType)
ParsedGeometryType get_parsed_geometry_type()

Determina quale tipo di nodi sarà interpretato come geometria.

SourceGeometryMode geometry_source_geometry_mode = 0 🔗

void set_source_geometry_mode(value: SourceGeometryMode)
SourceGeometryMode get_source_geometry_mode()

La sorgente della geometria utilizzata durante la preparazione.

StringName geometry_source_group_name = &"navigation_mesh_source_group" 🔗

void set_source_group_name(value: StringName)
StringName get_source_group_name()

Il nome del gruppo da scansionare per la geometria.

Utilizzato solo quando geometry_source_geometry_mode è SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN o SOURCE_GEOMETRY_GROUPS_EXPLICIT.

float region_merge_size = 20.0 🔗

void set_region_merge_size(value: float)
float get_region_merge_size()

Tutte le regioni con dimensioni inferiori a questa saranno unite a regioni più grandi, se possibile.

Nota: Questo valore sarà elevato al quadrato per calcolare il numero di celle. Ad esempio, un valore di 20 imposterà il numero di celle a 400.

float region_min_size = 2.0 🔗

void set_region_min_size(value: float)
float get_region_min_size()

La dimensione minima di una regione per la sua creazione.

Nota: Questo valore sarà elevato al quadrato per calcolare il numero minimo di celle autorizzate a formare aree insulari isolate. Ad esempio, un valore di 8 imposterà il numero di celle a 64.

SamplePartitionType sample_partition_type = 0 🔗

void set_sample_partition_type(value: SamplePartitionType)
SamplePartitionType get_sample_partition_type()

Algoritmo di partizionamento per la creazione dei poligoni della mesh di navigazione.

float vertices_per_polygon = 6.0 🔗

void set_vertices_per_polygon(value: float)
float get_vertices_per_polygon()

Il numero massimo di vertici consentiti per i poligoni generati durante il processo di conversione da contorno a poligono.

Descrizioni dei metodi

void add_polygon(polygon: PackedInt32Array) 🔗

Aggiunge un poligono utilizzando gli indici dei vertici ottenuti chiamando get_vertices().

void clear() 🔗

Svuota gli array interni per i vertici e gli indici dei poligoni.

void clear_polygons() 🔗

Svuota l'array di poligoni, ma non svuota l'array di vertici.

void create_from_mesh(mesh: Mesh) 🔗

Inizializza la mesh di navigazione impostando i vertici e gli indici secondo una Mesh.

Nota: mesh deve essere di tipo Mesh.PRIMITIVE_TRIANGLES e avere un array di indici.

bool get_collision_mask_value(layer_number: int) const 🔗

Restituisce se lo strato specificato della geometry_collision_mask è abilitato o meno, fornito un numero di strato layer_number tra 1 e 32.

PackedInt32Array get_polygon(idx: int) 🔗

Restituisce un PackedInt32Array contenente gli indici dei vertici di un poligono creato.

int get_polygon_count() const 🔗

Restituisce il numero di poligoni nella mesh di navigazione.

PackedVector3Array get_vertices() const 🔗

Restituisce un PackedVector3Array contenente tutti i vertici utilizzati per creare i poligoni.

void set_collision_mask_value(layer_number: int, value: bool) 🔗

In base a value, abilita o disabilita lo strato specificato nella geometry_collision_mask, fornito un layer_number tra 1 e 32.

void set_vertices(vertices: PackedVector3Array) 🔗

Imposta i vertici che possono essere poi indicizzati per creare poligoni con il metodo add_polygon().