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

Hereda: Node2D < CanvasItem < Node < Object

Nodo de cámara para escenas 2D.

Descripción

Nodo de cámara para escenas 2D. Fuerza a la pantalla (capa actual) a desplazarse siguiendo a este nodo. Esto hace que sea más fácil (y rápido) programar escenas con desplazamiento que cambiar manualmente la posición de los nodos basados en CanvasItem.

Las cámaras se registran en el nodo Viewport más cercano (al ascender por el árbol). Solo puede haber una cámara activa por viewport. Si no hay ningún viewport disponible al ascender por el árbol, la cámara se registrará en el viewport global.

Este nodo está pensado para ser una ayuda simple para empezar rápidamente, pero es posible que se desee más funcionalidad para cambiar cómo funciona la cámara. Para crear tu propio nodo de cámara personalizado, hereda de Node2D y cambia la transformación del lienzo estableciendo Viewport.canvas_transform en Viewport (puedes obtener el Viewport actual usando Node.get_viewport()).

Ten en cuenta que la Node2D.global_position del nodo Camera2D no representa la posición real de la pantalla, la cual puede diferir debido al suavizado o límites aplicados. Puedes usar get_screen_center_position() para obtener la posición real. Lo mismo ocurre con la Node2D.global_rotation del nodo, que puede ser diferente debido al suavizado de rotación aplicado. Puedes usar get_screen_rotation() para obtener la rotación actual de la pantalla.

Tutoriales

Propiedades

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)`

Métodos

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)

Enumeraciones

enum AnchorMode: 🔗

AnchorMode ANCHOR_MODE_FIXED_TOP_LEFT = 0

La posición de la cámara está fijada de tal manera que la esquina superior izquierda está siempre en el origen.

AnchorMode ANCHOR_MODE_DRAG_CENTER = 1

La posición de la cámara tiene en cuenta los desplazamientos verticales/horizontales y el tamaño de la pantalla.

enum Camera2DProcessCallback: 🔗

Camera2DProcessCallback CAMERA2D_PROCESS_PHYSICS = 0

La cámara se actualiza al mismo tiempo que la física (mira Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS).

Camera2DProcessCallback CAMERA2D_PROCESS_IDLE = 1

La cámara se actualiza en cada frame de imagen (mira Node.NOTIFICATION_INTERNAL_PROCESS).

Descripciones de Propiedades

AnchorMode anchor_mode = 1 🔗

void set_anchor_mode(value: AnchorMode)
AnchorMode get_anchor_mode()

El punto de anclaje de Camera2D.

Node custom_viewport 🔗

void set_custom_viewport(value: Node)
Node get_custom_viewport()

El nodo personalizado de Viewport unido a Camera2D. Si null o no es un Viewport, usa el viewport por defecto en su lugar.

float drag_bottom_margin = 0.2 🔗

void set_drag_margin(margin: Side, drag_margin: float)
float get_drag_margin(margin: Side) const

Margen inferior necesario para arrastrar la cámara. Un valor de 1 hace que la cámara se mueva solo cuando alcance el borde inferior de la pantalla.

bool drag_horizontal_enabled = false 🔗

void set_drag_horizontal_enabled(value: bool)
bool is_drag_horizontal_enabled()

Si es true, la cámara solo se mueve cuando alcanza los márgenes de arrastre horizontal (izquierdo y derecho). Si es false, la cámara se mueve horizontalmente independientemente de los márgenes.

float drag_horizontal_offset = 0.0 🔗

void set_drag_horizontal_offset(value: float)
float get_drag_horizontal_offset()

El desplazamiento de arrastre horizontal relativo de la cámara entre los márgenes de arrastre derecho (-1) e izquierdo (1).

Nota: Se utiliza para establecer el desplazamiento de arrastre horizontal inicial, determinar el desplazamiento actual u forzar el desplazamiento actual. No se actualiza automáticamente cuando drag_horizontal_enabled es true o se modifican los márgenes de arrastre.

float drag_left_margin = 0.2 🔗

void set_drag_margin(margin: Side, drag_margin: float)
float get_drag_margin(margin: Side) const

Margen izquierdo necesario para arrastrar la cámara. Un valor de 1 hace que la cámara se mueva solo cuando alcance el borde izquierdo de la pantalla.

float drag_right_margin = 0.2 🔗

void set_drag_margin(margin: Side, drag_margin: float)
float get_drag_margin(margin: Side) const

Right margin needed to drag the camera. A value of 1 makes the camera move only when reaching the right edge of the screen.

float drag_top_margin = 0.2 🔗

void set_drag_margin(margin: Side, drag_margin: float)
float get_drag_margin(margin: Side) const

Top margin needed to drag the camera. A value of 1 makes the camera move only when reaching the top edge of the screen.

bool drag_vertical_enabled = false 🔗

void set_drag_vertical_enabled(value: bool)
bool is_drag_vertical_enabled()

If true, the camera only moves when reaching the vertical (top and bottom) drag margins. If false, the camera moves vertically regardless of the drag margins.

float drag_vertical_offset = 0.0 🔗

void set_drag_vertical_offset(value: float)
float get_drag_vertical_offset()

El desplazamiento vertical relativo de arrastre (drag offset) de la cámara entre los márgenes de arrastre inferior (-1) y superior (1).

Nota: Se utiliza para establecer el desplazamiento vertical inicial de arrastre; determinar el desplazamiento actual; o forzar el desplazamiento actual. No se actualiza automáticamente cuando drag_vertical_enabled es true o se cambian los márgenes de arrastre.

bool editor_draw_drag_margin = false 🔗

void set_margin_drawing_enabled(value: bool)
bool is_margin_drawing_enabled()

Si es true, dibuja el rectángulo de margen de arrastre de la cámara en el editor.

bool editor_draw_limits = false 🔗

void set_limit_drawing_enabled(value: bool)
bool is_limit_drawing_enabled()

Si es true, dibuja el rectángulo de límites de la cámara en el editor.

bool editor_draw_screen = true 🔗

void set_screen_drawing_enabled(value: bool)
bool is_screen_drawing_enabled()

Si es true, dibuja el rectángulo de la pantalla de la cámara en el editor.

bool enabled = true 🔗

void set_enabled(value: bool)
bool is_enabled()

Controla si la cámara puede estar activa o no. Si es true, el Camera2D se convertirá en la cámara principal cuando entre en el árbol de escenas y no haya una cámara activa actualmente (ver Viewport.get_camera_2d()).

Cuando la cámara está activa actualmente y enabled se establece en false, el siguiente Camera2D habilitado en el árbol de escenas pasará a estar activo.

bool ignore_rotation = true 🔗

void set_ignore_rotation(value: bool)
bool is_ignoring_rotation()

Si es true, la vista renderizada de la cámara no se ve afectada por su Node2D.rotation ni por su Node2D.global_rotation.

int limit_bottom = 10000000 🔗

void set_limit(margin: Side, limit: int)
int get_limit(margin: Side) const

Bottom scroll limit in pixels. The camera stops moving when reaching this value, but offset can push the view past the limit.

bool limit_enabled = true 🔗

void set_limit_enabled(value: bool)
bool is_limit_enabled()

Si es true, los límites serán habilitados. Deshabilitar esto permitirá que la cámara se enfoque en cualquier lugar, por lo que las cuatro propiedades limit_* no funcionarán.

int limit_left = -10000000 🔗

void set_limit(margin: Side, limit: int)
int get_limit(margin: Side) const

Left scroll limit in pixels. The camera stops moving when reaching this value, but offset can push the view past the limit.

int limit_right = 10000000 🔗

void set_limit(margin: Side, limit: int)
int get_limit(margin: Side) const

Right scroll limit in pixels. The camera stops moving when reaching this value, but offset can push the view past the limit.

bool limit_smoothed = false 🔗

void set_limit_smoothing_enabled(value: bool)
bool is_limit_smoothing_enabled()

Si es true, la cámara se detiene suavemente cuando alcanza sus límites.

Esta propiedad no tiene efecto si position_smoothing_enabled es false.

Nota: Para actualizar inmediatamente la posición de la cámara para que esté dentro de los límites sin suavizado, incluso con este ajuste habilitado, invoque reset_smoothing().

int limit_top = -10000000 🔗

void set_limit(margin: Side, limit: int)
int get_limit(margin: Side) const

Top scroll limit in pixels. The camera stops moving when reaching this value, but offset can push the view past the limit.

Vector2 offset = Vector2(0, 0) 🔗

void set_offset(value: Vector2)
Vector2 get_offset()

The camera's relative offset. Useful for looking around or camera shake animations. The offsetted camera can go past the limits defined in limit_top, limit_bottom, limit_left and limit_right.

bool position_smoothing_enabled = false 🔗

void set_position_smoothing_enabled(value: bool)
bool is_position_smoothing_enabled()

If true, the camera's view smoothly moves towards its target position at position_smoothing_speed.

float position_smoothing_speed = 5.0 🔗

void set_position_smoothing_speed(value: float)
float get_position_smoothing_speed()

Speed in pixels per second of the camera's smoothing effect when position_smoothing_enabled is true.

Camera2DProcessCallback process_callback = 1 🔗

void set_process_callback(value: Camera2DProcessCallback)
Camera2DProcessCallback get_process_callback()

The camera's process callback.

bool rotation_smoothing_enabled = false 🔗

void set_rotation_smoothing_enabled(value: bool)
bool is_rotation_smoothing_enabled()

If true, the camera's view smoothly rotates, via asymptotic smoothing, to align with its target rotation at rotation_smoothing_speed.

Note: This property has no effect if ignore_rotation is true.

float rotation_smoothing_speed = 5.0 🔗

void set_rotation_smoothing_speed(value: float)
float get_rotation_smoothing_speed()

The angular, asymptotic speed of the camera's rotation smoothing effect when rotation_smoothing_enabled is true.

Vector2 zoom = Vector2(1, 1) 🔗

void set_zoom(value: Vector2)
Vector2 get_zoom()

El zoom de la cámara. Los valores más altos acercan más la vista. Por ejemplo, un zoom de Vector2(2.0, 2.0) acercará el doble en cada eje (la vista cubre un área cuatro veces más pequeña). En contraste, un zoom de Vector2(0.5, 0.5) alejará el doble en cada eje (la vista cubre un área cuatro veces más grande). Generalmente, los componentes X e Y siempre deben establecerse con el mismo valor, a menos que desees estirar la vista de la cámara.

Nota: FontFile.oversampling no tiene en cuenta el zoom de Camera2D. Esto significa que acercar o alejar la cámara hará que las fuentes de mapa de bits y las fuentes dinámicas rasterizadas (no MSDF) aparezcan borrosas o pixeladas, a menos que la fuente forme parte de un CanvasLayer que haga que ignore el zoom de la cámara. Para asegurar que el texto permanezca nítido independientemente del zoom, puedes habilitar el renderizado de fuentes MSDF activando ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field (se aplica solo a la fuente predeterminada del proyecto), o habilitando Campo de Distancia Firmado Multicanal en las opciones de importación de una DynamicFont para fuentes personalizadas. En las fuentes del sistema, se puede habilitar SystemFont.multichannel_signed_distance_field en el inspector.

Descripciones de Métodos

void align() 🔗

Alinea la cámara al nodo rastreado.

Nota: No es necesario llamar a force_update_scroll() después de este método.

void force_update_scroll() 🔗

Obliga a la cámara a actualizar el scroll inmediatamente.

float get_drag_margin(margin: Side) const 🔗

Devuelve el margen del Side especificado. Véase también drag_bottom_margin, drag_top_margin, drag_left_margin y drag_right_margin.

int get_limit(margin: Side) const 🔗

Devuelve el límite de la cámara para el Side especificado. Véase también limit_bottom, limit_top, limit_left y limit_right.

Vector2 get_screen_center_position() const 🔗

Devuelve el centro de la pantalla desde el punto de vista de esta cámara, en coordenadas globales.

Nota: La posición exacta a la que se dirige la cámara puede ser diferente. Véase get_target_position().

float get_screen_rotation() const 🔗

Devuelve la rotación actual de la pantalla desde el punto de vista de esta cámara.

Nota: La rotación de la pantalla puede ser diferente de Node2D.global_rotation si la cámara está rotando suavemente debido a rotation_smoothing_enabled.

Vector2 get_target_position() const 🔗

Devuelve la posición objetivo de esta cámara, en coordenadas globales.

Nota: El valor devuelto no es el mismo que Node2D.global_position, ya que se ve afectado por las propiedades de arrastre (drag). Tampoco es el mismo que la posición actual si position_smoothing_enabled es true (ver get_screen_center_position()).

bool is_current() const 🔗

Devuelve true si esta Camera2D es la cámara activa (véase Viewport.get_camera_2d()).

void make_current() 🔗

Fuerza a esta Camera2D a convertirse en la activa. enabled debe ser true.

void reset_smoothing() 🔗

Establece la posición de la cámara inmediatamente a su destino de suavizado actual.

Este método no tiene ningún efecto si position_smoothing_enabled es false.

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

Establece el margen del Side especificado. Véase también drag_bottom_margin, drag_top_margin, drag_left_margin y drag_right_margin.

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

Establece el límite de la cámara para el Side especificado. Véase también limit_bottom, limit_top, limit_left y limit_right.