Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

LookAtModifier3D

Eredita: SkeletonModifier3D < Node3D < Node < Object

Il LookAtModifier3D ruota un osso per puntare verso un obiettivo.

Descrizione

Questo SkeletonModification2D ruota un osso per puntare verso un obiettivo. È estremamente utile per muovere la testa di un personaggio per guardare il giocatore, ruotare una torretta per guardare un bersaglio o qualsiasi altro caso in cui si voglia far ruotare un osso verso qualcosa in modo rapido e facile.

Quando si applicano più LookAtModifier3D, il LookAtModifier3D assegnato all'osso padre deve essere posizionato sopra il LookAtModifier3D assegnato all'osso figlio nella lista, affinché i risultati dell'osso figlio siano corretti.

Proprietà

int

bone

-1

String

bone_name

""

float

duration

0.0

EaseType

ease_type

0

BoneAxis

forward_axis

4

int

origin_bone

String

origin_bone_name

NodePath

origin_external_node

OriginFrom

origin_from

0

Vector3

origin_offset

Vector3(0, 0, 0)

float

origin_safe_margin

0.1

float

primary_damp_threshold

float

primary_limit_angle

float

primary_negative_damp_threshold

float

primary_negative_limit_angle

float

primary_positive_damp_threshold

float

primary_positive_limit_angle

Axis

primary_rotation_axis

1

bool

relative

false

float

secondary_damp_threshold

float

secondary_limit_angle

float

secondary_negative_damp_threshold

float

secondary_negative_limit_angle

float

secondary_positive_damp_threshold

float

secondary_positive_limit_angle

bool

symmetry_limitation

NodePath

target_node

NodePath("")

TransitionType

transition_type

0

bool

use_angle_limitation

false

bool

use_secondary_rotation

true

Metodi

float

get_interpolation_remaining() const

bool

is_interpolating() const

bool

is_target_within_limitation() const

Enumerazioni

enum OriginFrom: 🔗

OriginFrom ORIGIN_FROM_SELF = 0

Come origine viene utilizzata la posizione di appoggio dell'osso specificato in bone.

OriginFrom ORIGIN_FROM_SPECIFIC_BONE = 1

Come origine viene utilizzata la posizione globale dell'appoggio dell'osso specificato in origin_bone.

Nota: Si consiglia di selezionare solo l'osso padre, a meno che non si abbia familiarità con il processo di elaborazione dell'osso. L'appoggio dell'osso specificato al momento dell'elaborazione di LookAtModifier3D viene utilizzato come riferimento. In altre parole, se si specifica un osso figlio e LookAtModifier3D fa muovere l'osso figlio, il risultato e la direzione renderizzati non corrisponderanno.

OriginFrom ORIGIN_FROM_EXTERNAL_NODE = 2

La posizione globale del Node3D specificato in origin_external_node viene utilizzata come origine.

Nota: Come per ORIGIN_FROM_SPECIFIC_BONE, quando si specifica un BoneAttachment3D con un osso figlio assegnato, il risultato renderizzato e la direzione non corrisponderanno.

Descrizioni delle proprietà

int bone = -1 🔗

  • void set_bone(value: int)

  • int get_bone()

Indice del bone_name nello Skeleton3D genitore.

String bone_name = "" 🔗

Il nome dell'osso dello Skeleton3D su cui opererà la modificazione.

float duration = 0.0 🔗

  • void set_duration(value: float)

  • float get_duration()

La durata dell'interpolazione basata sul tempo. L'interpolazione viene attivata nei seguenti casi:

  • Quando il nodo obiettivo viene modificato

  • Quando un asse viene capovolto a causa della limitazione dell'angolo

Nota: Il capovolgimento avviene quando l'obiettivo è al di fuori del limite angolare e l'asse di rotazione secondaria calcolato internamente del vettore in avanti viene capovolto. Visivamente, avviene quando l'obiettivo è al di fuori del limite angolare e attraversa il piano di forward_axis e primary_rotation_axis.

EaseType ease_type = 0 🔗

The ease type of the time-based interpolation. See also EaseType.

BoneAxis forward_axis = 4 🔗

L'asse in avanti dell'osso. Questo SkeletonModifier3D modifica l'osso in modo che questo asse punti verso il target_node.

int origin_bone 🔗

  • void set_origin_bone(value: int)

  • int get_origin_bone()

Indice del origin_bone_name nello Skeleton3D genitore.

String origin_bone_name 🔗

  • void set_origin_bone_name(value: String)

  • String get_origin_bone_name()

Se origin_from è ORIGIN_FROM_SPECIFIC_BONE, la posizione globale della posa dell'osso specificata per questo è utilizzata come origine.

NodePath origin_external_node 🔗

  • void set_origin_external_node(value: NodePath)

  • NodePath get_origin_external_node()

Se origin_from è ORIGIN_FROM_EXTERNAL_NODE, la posizione globale del Node3D specificato per questo è utilizzata come origine.

OriginFrom origin_from = 0 🔗

Questo valore determina da quale origine vengono recuperati i dati da utilizzare nel calcolo del vettore in avanti.

Vector3 origin_offset = Vector3(0, 0, 0) 🔗

L'offset dell'origine della posa d'ossa. Far corrispondere le origini tramite un offset è utile nei casi in cui più ossa devono sempre essere rivolte nella stessa direzione, come gli occhi.

Nota: Questo valore indica la posizione locale dell'oggetto impostato in origin_from.

float origin_safe_margin = 0.1 🔗

  • void set_origin_safe_margin(value: float)

  • float get_origin_safe_margin()

Se l'obiettivo passa troppo vicino all'origine rispetto a questo valore, viene utilizzata l'interpolazione basata sul tempo anche se l'obiettivo si trova entro i limiti angolari, per evitare che la velocità angolare diventi troppo elevata.

float primary_damp_threshold 🔗

  • void set_primary_damp_threshold(value: float)

  • float get_primary_damp_threshold()

La soglia per iniziare lo smorzamento per primary_limit_angle. Fornisce un'interpolazione non lineare (b-spline), facendo percepire più resistenza quanto più ruota verso il limite dei bordi. Ciò è utile per simulare i limiti del movimento umano.

Se 1.0, non viene effettuato alcuno smorzamento. Se 0.0, lo smorzamento viene sempre effettuato.

float primary_limit_angle 🔗

  • void set_primary_limit_angle(value: float)

  • float get_primary_limit_angle()

The limit angle of the primary rotation when symmetry_limitation is true, in radians.

float primary_negative_damp_threshold 🔗

  • void set_primary_negative_damp_threshold(value: float)

  • float get_primary_negative_damp_threshold()

La soglia per iniziare lo smorzamento per primary_negative_limit_angle.

float primary_negative_limit_angle 🔗

  • void set_primary_negative_limit_angle(value: float)

  • float get_primary_negative_limit_angle()

The limit angle of negative side of the primary rotation when symmetry_limitation is false, in radians.

float primary_positive_damp_threshold 🔗

  • void set_primary_positive_damp_threshold(value: float)

  • float get_primary_positive_damp_threshold()

La soglia per iniziare lo smorzamento per primary_positive_limit_angle.

float primary_positive_limit_angle 🔗

  • void set_primary_positive_limit_angle(value: float)

  • float get_primary_positive_limit_angle()

The limit angle of positive side of the primary rotation when symmetry_limitation is false, in radians.

Axis primary_rotation_axis = 1 🔗

  • void set_primary_rotation_axis(value: Axis)

  • Axis get_primary_rotation_axis()

L'asse della prima rotazione. Questo SkeletonModifier3D funziona componendo la rotazione tramite angoli di Eulero per impedire la rotazione di forward_axis.

bool relative = false 🔗

  • void set_relative(value: bool)

  • bool is_relative()

The relative option. If true, the rotation is applied relative to the pose. If false, the rotation is applied relative to the rest. It means to replace the current pose with the LookAtModifier3D's result.

Note: This option affects the base angle for use_angle_limitation. Since the LookAtModifier3D relies strongly on Euler rotation, the axis that determines the limitation and the actual rotation are strongly tied together.

float secondary_damp_threshold 🔗

  • void set_secondary_damp_threshold(value: float)

  • float get_secondary_damp_threshold()

La soglia per iniziare lo smorzamento per secondary_limit_angle.

float secondary_limit_angle 🔗

  • void set_secondary_limit_angle(value: float)

  • float get_secondary_limit_angle()

The limit angle of the secondary rotation when symmetry_limitation is true, in radians.

float secondary_negative_damp_threshold 🔗

  • void set_secondary_negative_damp_threshold(value: float)

  • float get_secondary_negative_damp_threshold()

La soglia per iniziare lo smorzamento per secondary_negative_limit_angle.

float secondary_negative_limit_angle 🔗

  • void set_secondary_negative_limit_angle(value: float)

  • float get_secondary_negative_limit_angle()

The limit angle of negative side of the secondary rotation when symmetry_limitation is false, in radians.

float secondary_positive_damp_threshold 🔗

  • void set_secondary_positive_damp_threshold(value: float)

  • float get_secondary_positive_damp_threshold()

La soglia per iniziare lo smorzamento per secondary_positive_limit_angle.

float secondary_positive_limit_angle 🔗

  • void set_secondary_positive_limit_angle(value: float)

  • float get_secondary_positive_limit_angle()

The limit angle of positive side of the secondary rotation when symmetry_limitation is false, in radians.

bool symmetry_limitation 🔗

  • void set_symmetry_limitation(value: bool)

  • bool is_limitation_symmetry()

If true, the limitations are spread from the bone symmetrically.

If false, the limitation can be specified separately for each side of the bone rest.

NodePath target_node = NodePath("") 🔗

Il NodePath al nodo che è l'obiettivo per la modificazione "look at". Questo nodo è ciò verso cui la modificazione ruoterà l'osso.

TransitionType transition_type = 0 🔗

Il tipo di transizione dell'interpolazione basata sul tempo. Vedi anche TransitionType.

bool use_angle_limitation = false 🔗

  • void set_use_angle_limitation(value: bool)

  • bool is_using_angle_limitation()

If true, limits the amount of rotation. For example, this helps to prevent a character's neck from rotating 360 degrees.

Note: As with AnimationTree blending, interpolation is provided that favors Skeleton3D.get_bone_rest() or Skeleton3D.get_bone_pose() depends on the relative option. This means that interpolation does not select the shortest path in some cases.

Note: Some values for transition_type (such as Tween.TRANS_BACK, Tween.TRANS_ELASTIC, and Tween.TRANS_SPRING) may exceed the limitations. If interpolation occurs while overshooting the limitations, the result might not respect the bone rest.

bool use_secondary_rotation = true 🔗

  • void set_use_secondary_rotation(value: bool)

  • bool is_using_secondary_rotation()

Se true, fornisce la rotazione su due assi.

Descrizioni dei metodi

float get_interpolation_remaining() const 🔗

Restituisce i secondi rimanenti dell'interpolazione basata sul tempo.

bool is_interpolating() const 🔗

Restituisce true se l'interpolazione basata sul tempo è in esecuzione. Se true, è equivalente a get_interpolation_remaining() quando restituisce 0.0.

Questo metodo è utile per determinare se è possibile rimuovere un LookAtModifier3D in modo sicuro.

bool is_target_within_limitation() const 🔗

Restituisce se l'obiettivo rientra nei limiti angolari. È utile per annullare l'impostazione di target_node quando l'obiettivo è al di fuori dei limiti angolari.

Nota: Il valore viene aggiornato dopo SkeletonModifier3D._process_modification(). Per recuperare correttamente questo valore, consigliamo di utilizzare il segnale SkeletonModifier3D.modification_processed.