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...

Camera2D

Eredita: Node2D < CanvasItem < Node < Object

Nodo di telecamera per le scene in 2D.

Descrizione

Nodo telecamera per le scene 2D. Forza lo schermo (livello attuale) a scorrere seguendo questo nodo. Ciò rende più facile (e veloce) programmare scene scorrevoli rispetto alla modifica manuale della posizione dei nodi basati su CanvasItem.

Le telecamere si registrano nel nodo Viewport più vicino (quando si sale nell'albero). Solo una telecamera può essere attiva per ogni viewport. Se non è disponibile alcuna viewport salendo nell'albero, la telecamera si registrerà nella viewport globale.

Questo nodo è pensato come aiuto per far funzionare le cose rapidamente, ma potrebbero essere desiderate più funzionalità per cambiare il modo in cui funziona la telecamera. Per creare il tuo nodo telecamera personalizzato, ereditalo da Node2D e modifica la trasformazione del canvas impostando Viewport.canvas_transform in Viewport (puoi ottenere la Viewport attuale tramite Node.get_viewport()).

Nota che la Node2D.global_position del nodo Camera2D non rappresenta la posizione effettiva dello schermo, che potrebbe differire a causa di attenuazioni o limiti applicati. Puoi usare get_screen_center_position() per ottenere la posizione reale. Lo stesso vale per la Node2D.global_rotation del nodo, che potrebbe essere diversa a causa dell'applicazione dell'attenuazione della rotazione. È possibile usare get_screen_rotation() per ottenere la rotazione attuale dello schermo.

Tutorial

Proprietà

AnchorMode

anchor_mode

1

Node

custom_viewport

float

drag_bottom_margin

0.2

bool

drag_horizontal_enabled

false

float

drag_horizontal_offset

0.0

float

drag_left_margin

0.2

float

drag_right_margin

0.2

float

drag_top_margin

0.2

bool

drag_vertical_enabled

false

float

drag_vertical_offset

0.0

bool

editor_draw_drag_margin

false

bool

editor_draw_limits

false

bool

editor_draw_screen

true

bool

enabled

true

bool

ignore_rotation

true

int

limit_bottom

10000000

bool

limit_enabled

true

int

limit_left

-10000000

int

limit_right

10000000

bool

limit_smoothed

false

int

limit_top

-10000000

Vector2

offset

Vector2(0, 0)

bool

position_smoothing_enabled

false

float

position_smoothing_speed

5.0

Camera2DProcessCallback

process_callback

1

bool

rotation_smoothing_enabled

false

float

rotation_smoothing_speed

5.0

Vector2

zoom

Vector2(1, 1)

Metodi

void

align()

void

force_update_scroll()

float

get_drag_margin(margin: Side) const

int

get_limit(margin: Side) const

Vector2

get_screen_center_position() const

float

get_screen_rotation() const

Vector2

get_target_position() const

bool

is_current() const

void

make_current()

void

reset_smoothing()

void

set_drag_margin(margin: Side, drag_margin: float)

void

set_limit(margin: Side, limit: int)

Enumerazioni

enum AnchorMode: 🔗

AnchorMode ANCHOR_MODE_FIXED_TOP_LEFT = 0

La posizione della telecamera è fissa in modo che l'angolo in alto a sinistra sia sempre all'origine.

AnchorMode ANCHOR_MODE_DRAG_CENTER = 1

La posizione della telecamera tiene conto degli spostamenti verticale e orizzontale, e delle dimensioni dello schermo.

enum Camera2DProcessCallback: 🔗

Camera2DProcessCallback CAMERA2D_PROCESS_PHYSICS = 0

La telecamera si aggiorna durante i frame di fisica (vedi Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS).

Camera2DProcessCallback CAMERA2D_PROCESS_IDLE = 1

La telecamera si aggiorna durante i frame di processo (vedi Node.NOTIFICATION_INTERNAL_PROCESS).

Descrizioni delle proprietà

AnchorMode anchor_mode = 1 🔗

Il punto di ancoraggio della Camera2D.

Node custom_viewport 🔗

  • void set_custom_viewport(value: Node)

  • Node get_custom_viewport()

Il nodo Viewport personalizzato associato alla Camera2D. Se null o non è una Viewport, utilizza invece la viewport predefinita.

float drag_bottom_margin = 0.2 🔗

  • void set_drag_margin(margin: Side, drag_margin: float)

  • float get_drag_margin(margin: Side) const

Margine inferiore necessario per trascinare la telecamera. Un valore di 1 fa muovere la telecamera solo quando raggiunge il bordo inferiore dello schermo.

bool drag_horizontal_enabled = false 🔗

  • void set_drag_horizontal_enabled(value: bool)

  • bool is_drag_horizontal_enabled()

Se true, la telecamera si muove solo quando raggiunge i margini di trascinamento orizzontali (sinistro e destro). Se false, la telecamera si sposta orizzontalmente a prescindere dai margini di trascinamento.

float drag_horizontal_offset = 0.0 🔗

  • void set_drag_horizontal_offset(value: float)

  • float get_drag_horizontal_offset()

Offset di trascinamento orizzontale relativo della telecamera tra i margini di trascinamento destro (-1) e sinistro (1).

Nota: Utilizzato per impostare l'offset di trascinamento orizzontale iniziale; determinare l'offset attuale; o forzare l'offset attuale. Non viene aggiornato automaticamente quando drag_horizontal_enabled è true o i margini di trascinamento vengono modificati.

float drag_left_margin = 0.2 🔗

  • void set_drag_margin(margin: Side, drag_margin: float)

  • float get_drag_margin(margin: Side) const

Margine sinistro necessario per trascinare la telecamera. Un valore di 1 fa muovere la telecamera solo quando raggiunge il bordo sinistro dello schermo.

float drag_right_margin = 0.2 🔗

  • void set_drag_margin(margin: Side, drag_margin: float)

  • float get_drag_margin(margin: Side) const

Margine destro necessario per trascinare la telecamera. Un valore di 1 fa muovere la telecamera solo quando raggiunge il bordo destro dello schermo.

float drag_top_margin = 0.2 🔗

  • void set_drag_margin(margin: Side, drag_margin: float)

  • float get_drag_margin(margin: Side) const

Margine superiore necessario per trascinare la telecamera. Un valore di 1 fa muovere la telecamera solo quando raggiunge il bordo superiore dello schermo.

bool drag_vertical_enabled = false 🔗

  • void set_drag_vertical_enabled(value: bool)

  • bool is_drag_vertical_enabled()

Se true, la telecamera si muove solo quando raggiunge i margini di trascinamento verticali (sopra e sotto). Se false, la telecamera si sposta verticalmente a prescindere dai margini di trascinamento.

float drag_vertical_offset = 0.0 🔗

  • void set_drag_vertical_offset(value: float)

  • float get_drag_vertical_offset()

Offset di trascinamento verticale relativo della telecamera tra i margini di trascinamento inferiore (-1) e superiore (1).

Nota: Utilizzato per impostare l'offset di trascinamento verticale iniziale; determinare l'offset attuale; o forzare l'offset attuale. Non viene aggiornato automaticamente quando drag_vertical_enabled è true o i margini di trascinamento vengono modificati.

bool editor_draw_drag_margin = false 🔗

  • void set_margin_drawing_enabled(value: bool)

  • bool is_margin_drawing_enabled()

Se true, disegna il rettangolo del margine di trascinamento della telecamera nell'editor.

bool editor_draw_limits = false 🔗

  • void set_limit_drawing_enabled(value: bool)

  • bool is_limit_drawing_enabled()

Se true, disegna il rettangolo dei limiti della telecamera nell'editor.

bool editor_draw_screen = true 🔗

  • void set_screen_drawing_enabled(value: bool)

  • bool is_screen_drawing_enabled()

Se true, disegna il rettangolo dello schermo della telecamera nell'editor.

bool enabled = true 🔗

  • void set_enabled(value: bool)

  • bool is_enabled()

Controlla se la fotocamera può essere attiva o meno. Se true, la Camera2D diventerà la telecamera principale quando entra nell'albero di scene e non vi è alcuna telecamera attiva attuale (vedi Viewport.get_camera_2d()).

Quando la telecamera è attualmente attiva e enabled è impostato su false, la successiva Camera2D abilitata nell'albero di scene diventerà attiva.

bool ignore_rotation = true 🔗

  • void set_ignore_rotation(value: bool)

  • bool is_ignoring_rotation()

Se true, la vista renderizzata della telecamera non è influenzata dal suo Node2D.rotation e Node2D.global_rotation.

int limit_bottom = 10000000 🔗

  • void set_limit(margin: Side, limit: int)

  • int get_limit(margin: Side) const

Limite di scorrimento inferiore in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma offset può spingere la vista oltre il limite.

bool limit_enabled = true 🔗

  • void set_limit_enabled(value: bool)

  • bool is_limit_enabled()

Se true, i limiti saranno abilitati. Disabilitandoli, la telecamera potrà focalizzarsi ovunque, quando le quattro proprietà limit_* non funzioneranno.

int limit_left = -10000000 🔗

  • void set_limit(margin: Side, limit: int)

  • int get_limit(margin: Side) const

Limite di scorrimento sinistro in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma offset può spingere la vista oltre il limite.

int limit_right = 10000000 🔗

  • void set_limit(margin: Side, limit: int)

  • int get_limit(margin: Side) const

Limite di scorrimento destro in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma offset può spingere la vista oltre il limite.

bool limit_smoothed = false 🔗

  • void set_limit_smoothing_enabled(value: bool)

  • bool is_limit_smoothing_enabled()

Se true, la fotocamera si ferma dolcemente quando raggiunge i suoi limiti.

Questa proprietà non ha effetto se position_smoothing_enabled è false.

Nota: Per aggiornare immediatamente la posizione della telecamera in modo che rientri nei limiti di attenuazione, anche con questa impostazione abilitata, invoca reset_smoothing().

int limit_top = -10000000 🔗

  • void set_limit(margin: Side, limit: int)

  • int get_limit(margin: Side) const

Limite di scorrimento superiore in pixel. La telecamera smette di muoversi quando raggiunge questo valore, ma offset può spingere la vista oltre il limite.

Vector2 offset = Vector2(0, 0) 🔗

Spostamento relativo della fotocamera. Utile per guardarsi intorno o animazioni di scuotimento dalla telecamera. La telecamera spostata può superare i limiti definiti in limit_top, limit_bottom, limit_left, e limit_right.

bool position_smoothing_enabled = false 🔗

  • void set_position_smoothing_enabled(value: bool)

  • bool is_position_smoothing_enabled()

Se true, la vista della telecamera si muove fluidamente verso la sua posizione di destinazione alla velocità di position_smoothing_speed.

float position_smoothing_speed = 5.0 🔗

  • void set_position_smoothing_speed(value: float)

  • float get_position_smoothing_speed()

Velocità in pixel al secondo dell'effetto di attenuazione della fotocamera quando position_smoothing_enabled è true.

Camera2DProcessCallback process_callback = 1 🔗

Il callback di processo della telecamera.

bool rotation_smoothing_enabled = false 🔗

  • void set_rotation_smoothing_enabled(value: bool)

  • bool is_rotation_smoothing_enabled()

Se true, la visuale della telecamera ruota dolcemente, tramite attenuazione asintotica, per allinearsi con la rotazione di destinazione a rotation_smoothing_speed.

Nota: Questa proprietà non ha effetto se ignore_rotation è true.

float rotation_smoothing_speed = 5.0 🔗

  • void set_rotation_smoothing_speed(value: float)

  • float get_rotation_smoothing_speed()

Velocità angolare asintotica dell'effetto di attenuazione della rotazione della telecamera quando rotation_smoothing_enabled è true.

Vector2 zoom = Vector2(1, 1) 🔗

Lo zoom della telecamera. Valori più alti risultano in un ingrandimento maggiore. Ad esempio, uno zoom di Vector2(2.0, 2.0) raddoppia l'ingrandimento su ciascun asse (la vista copre un'area quattro volte più piccola). Al contrario, uno zoom di Vector2(0.5, 0.5) rimpicciolirà di due volte su ciascun asse (la vista copre un'area quattro volte più grande). In genere, le componenti X e Y si dovrebbero sempre impostare sullo stesso valore, a meno che non si desideri stirare la vista della telecamera.

Nota: FontFile.oversampling non tiene conto dello zoom della Camera2D. Ciò significa che lo zoom in avanti/indietro farà in modo che i font bitmap e i font dinamici rasterizzati (non MSDF) appaiano sfocati o pixelati, a meno che il font non faccia parte di un CanvasLayer che gli fa ignorare lo zoom della telecamera. Per garantire che il testo rimanga nitido a prescindere dallo zoom, è possibile abilitare il rendering dei font MSDF abilitando ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (si applica solo al font predefinito del progetto) o abilitando Multichannel Signed Distance Field nelle opzioni di importazione di un DynamicFont per i font personalizzati. Sui font di sistema, è possibile abilitare SystemFont.multichannel_signed_distance_field nell'Ispettore.

Descrizioni dei metodi

void align() 🔗

Aligns the camera to the tracked node.

Note: Calling force_update_scroll() after this method is not required.

void force_update_scroll() 🔗

Forza la telecamera ad aggiornare lo scorrimento immediatamente.

float get_drag_margin(margin: Side) const 🔗

Restituisce il margine del lato specificato (vedi Side). Vedi anche drag_bottom_margin, drag_top_margin, drag_left_margin, e drag_right_margin.

int get_limit(margin: Side) const 🔗

Restituisce il limite della telecamera per il lato specificato (vedi Side). Vedi anche limit_bottom, limit_top, limit_left, e limit_right.

Vector2 get_screen_center_position() const 🔗

Restituisce il centro dello schermo dal punto di vista di questa telecamera, in coordinate globali.

Nota: L'esatta posizione di destinazione della fotocamera potrebbe essere diversa. Vedi get_target_position().

float get_screen_rotation() const 🔗

Restituisce la rotazione attuale dello schermo dal punto di vista di questa telecamera.

Nota: La rotazione dello schermo può essere diversa da Node2D.global_rotation se la telecamera ruota in modo fluido a causa di rotation_smoothing_enabled.

Vector2 get_target_position() const 🔗

Restituisce la posizione di destinazione di questa telecamera, in coordinate globali.

Nota: Il valore restituito non è lo stesso di Node2D.global_position, poiché è influenzato dalle proprietà di trascinamento. Inoltre, non è lo stesso della posizione attuale se position_smoothing_enabled è true (vedi get_screen_center_position()).

bool is_current() const 🔗

Restituisce true se questa Camera2D è la telecamera attiva (vedi Viewport.get_camera_2d()).

void make_current() 🔗

Forza questa Camera2D a diventare quella attualmente attiva. enabled deve essere true.

void reset_smoothing() 🔗

Imposta la posizione della telecamera immediatamente sulla sua destinazione di attenuamento corrente.

Questo metodo non ha alcun effetto se position_smoothing_enabled è false.

void set_drag_margin(margin: Side, drag_margin: float) 🔗

Imposta il margine del lato specificato (vedi Side). Vedi anche drag_bottom_margin, drag_top_margin, drag_left_margin, e drag_right_margin.

void set_limit(margin: Side, limit: int) 🔗

Imposta il limite della telecamera per il lato specificato (vedi Side). Vedi anche limit_bottom, limit_top, limit_left, e limit_right.