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...
Camera3D
Eredita: Node3D < Node < Object
Ereditato da: XRCamera3D
Nodo telecamera, è visualizzato da un punto di vista.
Descrizione
Camera3D è un nodo speciale che mostra ciò che è visibile dalla sua posizione attuale. Le telecamere si registrano nel nodo Viewport più vicino (quando si risale l'albero). Solo una telecamera può essere attiva per viewport. Se non è disponibile alcuna viewport risalendo l'albero, la telecamera sarà registrata nella viewport globale. In altre parole, una telecamera fornisce funzionalità di visualizzazione 3D a una Viewport e, senza di essa, una scena registrata in tale Viewport (o in viewport superiori) non può essere visualizzata.
Tutorial
Proprietà
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
Metodi
void |
clear_current(enable_next: bool = true) |
get_camera_projection() const |
|
get_camera_rid() const |
|
get_camera_transform() const |
|
get_cull_mask_value(layer_number: int) const |
|
get_frustum() const |
|
is_position_behind(world_point: Vector3) const |
|
is_position_in_frustum(world_point: Vector3) const |
|
void |
|
project_local_ray_normal(screen_point: Vector2) const |
|
project_position(screen_point: Vector2, z_depth: float) const |
|
project_ray_normal(screen_point: Vector2) const |
|
project_ray_origin(screen_point: Vector2) const |
|
void |
set_cull_mask_value(layer_number: int, value: bool) |
void |
set_frustum(size: float, offset: Vector2, z_near: float, z_far: float) |
void |
set_orthogonal(size: float, z_near: float, z_far: float) |
void |
set_perspective(fov: float, z_near: float, z_far: float) |
unproject_position(world_point: Vector3) const |
Enumerazioni
enum ProjectionType: 🔗
ProjectionType PROJECTION_PERSPECTIVE = 0
Proiezione prospettica. Gli oggetti sullo schermo diventano più piccoli quando sono lontani.
ProjectionType PROJECTION_ORTHOGONAL = 1
Proiezione ortogonale, detta anche proiezione ortografica. Gli oggetti rimangono delle stesse dimensioni sullo schermo, a prescindere dalla loro distanza.
ProjectionType PROJECTION_FRUSTUM = 2
Proiezione troncoconica. Questa modalità consente di regolare frustum_offset per creare effetti di "tronco inclinato".
enum KeepAspect: 🔗
KeepAspect KEEP_WIDTH = 0
Mantiene le proporzioni orizzontali; noto anche come ridimensionamento verticale. Questa è solitamente l'opzione migliore per i progetti eseguiti in modalità ritratto, poiché rapporti di aspetto più alti godranno di un FOV verticale più ampio.
KeepAspect KEEP_HEIGHT = 1
Mantiene le proporzioni verticali; noto anche come ridimensionamento orizzontale. Questa è solitamente l'opzione migliore per i progetti eseguiti in modalità orizzontale, poiché rapporti di aspetto più larghi godranno di un FOV orizzontale più ampio.
enum DopplerTracking: 🔗
DopplerTracking DOPPLER_TRACKING_DISABLED = 0
Disabilita la simulazione dell'effetto Doppler (impostazione predefinita).
DopplerTracking DOPPLER_TRACKING_IDLE_STEP = 1
Simula l'effetto Doppler monitorando le posizioni degli oggetti che cambiano in _process. I cambiamenti nella velocità relativa di questa telecamera rispetto a tali oggetti influiscono sul modo in cui l'audio viene percepito, modificando la scala del tono (AudioStreamPlayer3D.pitch_scale) dell'audio.
DopplerTracking DOPPLER_TRACKING_PHYSICS_STEP = 2
Simula l'effetto Doppler monitorando le posizioni degli oggetti che cambiano in _physics_process. I cambiamenti nella velocità relativa di questa telecamera rispetto a tali oggetti influiscono sul modo in cui l'audio viene percepito, modificando la scala del tono (AudioStreamPlayer3D.pitch_scale) dell'audio.
Descrizioni delle proprietà
CameraAttributes attributes 🔗
void set_attributes(value: CameraAttributes)
CameraAttributes get_attributes()
La risorsa di attributi da utilizzare per questa telecamera.
Compositor compositor 🔗
void set_compositor(value: Compositor)
Compositor get_compositor()
Il Compositor da utilizzare per questa telecamera.
La maschera di culling che descrive quali strati (VisualInstance3D.layers) sono renderizzati da questa telecamera. Come valore predefinito, sono renderizzati tutti i 20 strati visibili all'utente.
Nota: Poiché cull_mask consente di memorizzare 32 strati in totale, ci sono altri 12 strati che sono utilizzati solo internamente dal motore e non sono esposti nell'editor. Impostare cull_mask tramite uno script consente di attivare o disattivare i livelli riservati, il che può essere utile per le estensioni dell'editor.
Per regolare cull_mask più facilmente tramite uno script, usa get_cull_mask_value() e set_cull_mask_value().
Nota: VoxelGI, SDFGI e LightmapGI considereranno sempre tutti gli strati per determinare cosa contribuisce all'illuminazione globale. Se questo è un problema, imposta GeometryInstance3D.gi_mode su GeometryInstance3D.GI_MODE_DISABLED per le mesh, e Light3D.light_bake_mode su Light3D.BAKE_DISABLED per le luci affinché siano escluse dall'illuminazione globale.
Se true, la Viewport antenato sta attualmente usando questa telecamera.
Se nella scena sono presenti più telecamere, una diventerà sempre attuale. Ad esempio, se nella scena sono presenti due nodi Camera3D e solo uno è attuale, impostando il current di una telecamera su false costringerà l'altra telecamera a diventare attuale.
DopplerTracking doppler_tracking = 0 🔗
void set_doppler_tracking(value: DopplerTracking)
DopplerTracking get_doppler_tracking()
Se non è DOPPLER_TRACKING_DISABLED, questa telecamera simulerà l'effetto Doppler per gli oggetti modificati in particolari metodi _process.
Nota: L'effetto Doppler sarà udibile solo sugli AudioStreamPlayer3D se AudioStreamPlayer3D.doppler_tracking non è impostato su AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED.
Environment environment 🔗
void set_environment(value: Environment)
Environment get_environment()
La risorsa Environment da utilizzare per questa telecamera.
La distanza dal limite di culling più lontano per questa fotocamera rispetto al suo asse Z locale. I valori più alti consentono alla telecamera di vedere più lontano, e ridurre far può migliorare le prestazioni se risulterebbe che oggetti diventino parzialmente o completamente scartati.
L'angolo del campo visivo della telecamera (in gradi). Applicabile solo in modalità prospettiva. Poiché keep_aspect blocca un asse, fov imposta l'angolo del campo visivo dell'altro asse.
Per riferimento, il valore del campo visivo verticale predefinito (75.0) è equivalente a un FOV orizzontale di:
~91,31 gradi in una vista a 4:3
~101,67 gradi in una vista a 16:10
~107,51 gradi in una vista a 16:9
~121,63 gradi in una vista a 21:9
Vector2 frustum_offset = Vector2(0, 0) 🔗
Offset del tronco della telecamera. Questo può essere modificato rispetto all'impostazione predefinita per creare effetti di "tronco inclinato" come Y-shearing.
Nota: Efficace solo se projection è PROJECTION_FRUSTUM.
L'offset orizzontale (X) della vista della telecamera.
KeepAspect keep_aspect = 1 🔗
void set_keep_aspect_mode(value: KeepAspect)
KeepAspect get_keep_aspect_mode()
L'asse da bloccare quando si regola fov o size. Può essere KEEP_WIDTH o KEEP_HEIGHT.
La distanza dal limite più vicino di culling per questa fotocamera rispetto al suo asse Z locale. Valori più bassi consentono alla telecamera di vedere gli oggetti più vicini alla sua origine, al costo di una precisione minore su l'intero intervallo. Valori inferiori a quelli predefiniti possono portare a un aumento dello Z-fighting.
ProjectionType projection = 0 🔗
void set_projection(value: ProjectionType)
ProjectionType get_projection()
La modalità di proiezione della telecamera. Nella modalità PROJECTION_PERSPECTIVE, la distanza Z degli oggetti dallo spazio locale della telecamera ridimensiona la loro dimensione percepita.
Le dimensioni della telecamera in metri misurate come il diametro della larghezza o altezza, a seconda di keep_aspect. Applicabile solo nelle modalità ortogonale e troncoconica.
L'offset verticale (Y) della vista della telecamera.
Descrizioni dei metodi
void clear_current(enable_next: bool = true) 🔗
Se questa è la telecamera attuale, la rimuove dall'attuale. Se enable_next è true, richiede di rendere attuale la telecamera successiva, se presente.
Projection get_camera_projection() const 🔗
Restituisce la matrice di proiezione utilizzata da questa telecamera per eseguire il rendering nella viewport associata. La telecamera deve essere all'interno dell'albero di scene per funzionare.
Restituisce il RID della telecamera dal RenderingServer.
Transform3D get_camera_transform() const 🔗
Restituisce la trasformazione della telecamera più gli spostamenti verticale (v_offset) e orizzontale (h_offset); e qualsiasi altra regolazione apportata alla posizione e all'orientamento della telecamera da telecamere di sottoclassi come XRCamera3D.
bool get_cull_mask_value(layer_number: int) const 🔗
Restituisce se lo strato specificato di cull_mask è abilitato o meno, dato un layer_number compreso tra 1 e 20.
Array[Plane] get_frustum() const 🔗
Restituisce i piani troncoconici della telecamera in unità di spazio mondiale come un array di Plane nell'ordine seguente: vicino, lontano, sinistro, alto, destro, basso. Da non confondere con frustum_offset.
Restituisce il RID di una forma piramidale che racchiude il tronco di vista della telecamera, ignorando il piano vicino della telecamera. La punta della piramide rappresenta la posizione della telecamera.
bool is_position_behind(world_point: Vector3) const 🔗
Restituisce true se la posizione indicata è dietro la telecamera (la parte blu del diagramma collegato). Vedi questo diagramma per una panoramica dei metodi di richiesta della posizione.
Nota: Una posizione che restituisce false potrebbe essere ancora fuori dal campo visivo della telecamera.
bool is_position_in_frustum(world_point: Vector3) const 🔗
Restituisce true se la posizione data è all'interno del tronco della telecamera (la parte verde del diagramma collegato). Vedi questo diagramma per una panoramica dei metodi di richiesta della posizione.
void make_current() 🔗
Rende questa telecamera la telecamera attuale per la Viewport (vedi la descrizione della classe). Se il nodo telecamera non è all'interno dell'albero di scene, tenterà di diventare attuale una volta aggiunto.
Vector3 project_local_ray_normal(screen_point: Vector2) const 🔗
Restituisce un vettore normale dalla posizione del punto sullo schermo diretto lungo la telecamera. Le telecamere ortogonali sono normalizzate. Le telecamere prospettiche tengono conto della prospettiva, della larghezza e altezza dello schermo, ecc.
Vector3 project_position(screen_point: Vector2, z_depth: float) const 🔗
Restituisce il punto 3D nello spazio mondiale che corrisponde alla coordinata 2D indicata nel rettangolo di Viewport su un piano che è lontano z_depth unità dalla telecamera.
Vector3 project_ray_normal(screen_point: Vector2) const 🔗
Restituisce un vettore normale nello spazio mondiale, ottenuto proiettando un punto sul rettangolo della Viewport mediante la proiezione inversa della telecamera. Ciò è utile per proiettare raggi sotto forma di (origine, normale) per l'intersezione o la selezione di oggetti.
Vector3 project_ray_origin(screen_point: Vector2) const 🔗
Restituisce una posizione 3D nello spazio mondiale, ottenuto proiettando un punto sul rettangolo della Viewport mediante la proiezione inversa della telecamera. Ciò è utile per proiettare raggi sotto forma di (origine, normale) per l'intersezione o la selezione di oggetti.
void set_cull_mask_value(layer_number: int, value: bool) 🔗
In base a value, abilita o disabilita il livello specificato in cull_mask, dato un layer_number compreso tra 1 e 20.
void set_frustum(size: float, offset: Vector2, z_near: float, z_far: float) 🔗
Sets the camera projection to frustum mode (see PROJECTION_FRUSTUM), by specifying a size, an offset, and the z_near and z_far clip planes in world space units. The size parameter represents the size of the near plane, either its width or height depending on the value of keep_aspect. See also frustum_offset.
void set_orthogonal(size: float, z_near: float, z_far: float) 🔗
Imposta la proiezione della telecamera in modalità ortogonale (vedi PROJECTION_ORTHOGONAL), specificando una dimensione size e i piani di ritaglio z_near e z_far in unità di spazio mondiale.
Come suggerimento, i giochi 3D che sembrano 2D utilizzano spesso questa proiezione, con size specificato in pixel.
void set_perspective(fov: float, z_near: float, z_far: float) 🔗
Imposta la proiezione della telecamera sulla modalità prospettiva (vedi PROJECTION_PERSPECTIVE), specificando un angolo fov (campo visivo) in gradi e i piani di ritaglio z_near e z_far in unità di spazio mondiale.
Vector2 unproject_position(world_point: Vector3) const 🔗
Restituisce le coordinate 2D nel rettangolo della Viewport che mappa al punto 3D specificato in spazio mondiale.
Nota: Quando si usa per posizionare gli elementi della GUI su una viewport 3D, usa is_position_behind() per evitare che appaiano se il punto 3D è dietro la telecamera:
# Questo blocco di codice fa parte di uno script che eredita da Node3D.
# `control` è un riferimento a un nodo che eredita da Control.
control.visible = not get_viewport().get_camera_3d().is_position_behind(global_transform.origin)
control.position = get_viewport().get_camera_3d().unproject_position(global_transform.origin)