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

Hereda: Node3D < Node < Object

Heredado por: XRCamera3D

Nodo de cámara, muestra desde un punto de vista.

Descripción

Camera3D is a special node that displays what is visible from its current location. Cameras register themselves in the nearest Viewport node (when ascending the tree). Only one camera can be active per viewport. If no viewport is available ascending the tree, the camera will register in the global viewport. In other words, a camera just provides 3D display capabilities to a Viewport, and, without one, a scene registered in that Viewport (or higher viewports) can't be displayed.

Tutoriales

Demo de Shooter en Tercera Persona (TPS)

Propiedades

CameraAttributes	attributes
Compositor	compositor
int	cull_mask	`1048575`
bool	current	`false`
DopplerTracking	doppler_tracking	`0`
Environment	environment
float	far	`4000.0`
float	fov	`75.0`
Vector2	frustum_offset	`Vector2(0, 0)`
float	h_offset	`0.0`
KeepAspect	keep_aspect	`1`
float	near	`0.05`
ProjectionType	projection	`0`
float	size	`1.0`
float	v_offset	`0.0`

Métodos

void	clear_current(enable_next: bool = true)
Projection	get_camera_projection() const
RID	get_camera_rid() const
Transform3D	get_camera_transform() const
bool	get_cull_mask_value(layer_number: int) const
Array[Plane]	get_frustum() const
RID	get_pyramid_shape_rid()
bool	is_position_behind(world_point: Vector3) const
bool	is_position_in_frustum(world_point: Vector3) const
void	make_current()
Vector3	project_local_ray_normal(screen_point: Vector2) const
Vector3	project_position(screen_point: Vector2, z_depth: float) const
Vector3	project_ray_normal(screen_point: Vector2) const
Vector3	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)
Vector2	unproject_position(world_point: Vector3) const

Enumeraciones

enum ProjectionType: 🔗

ProjectionType PROJECTION_PERSPECTIVE = 0

Proyección de la perspectiva. Los objetos en la pantalla se hacen más pequeños cuando están lejos.

ProjectionType PROJECTION_ORTHOGONAL = 1

Proyección ortogonal, también conocida como proyección ortográfica. Los objetos permanecen del mismo tamaño en la pantalla sin importar lo lejos que estén.

ProjectionType PROJECTION_FRUSTUM = 2

Proyección de Frustum. Este modo permite ajustar frustum_offset para crear efectos de "frustum inclinado".

enum KeepAspect: 🔗

KeepAspect KEEP_WIDTH = 0

Preserva la relación de aspecto horizontal; también conocida como escala de Vert-. Esta suele ser la mejor opción para los proyectos que se ejecutan en modo de retrato, ya que las proporciones de aspecto más altas se beneficiarán de un mayor FOV vertical.

KeepAspect KEEP_HEIGHT = 1

Preserva la relación de aspecto vertical; también conocida como escala Hor+. Esta suele ser la mejor opción para los proyectos que se ejecutan en modo paisaje, ya que las relaciones de aspecto más amplias se beneficiarán automáticamente de un FOV horizontal más amplio.

enum DopplerTracking: 🔗

DopplerTracking DOPPLER_TRACKING_DISABLED = 0

Desactiva la simulación del efecto Doppler (por defecto).

DopplerTracking DOPPLER_TRACKING_IDLE_STEP = 1

Simula el efecto Doppler rastreando las posiciones de los objetos que cambian en _process. Los cambios en la velocidad relativa de esta cámara en comparación con esos objetos afectan a cómo se percibe el audio (cambiando el AudioStreamPlayer3D.pitch_scale del audio).

DopplerTracking DOPPLER_TRACKING_PHYSICS_STEP = 2

Simular el efecto Doppler rastreando las posiciones de los objetos que cambian en _physics_process. Los cambios en la velocidad relativa de esta cámara en comparación con esos objetos afectan a cómo se percibe el audio (cambiando el AudioStreamPlayer3D.pitch_scale del audio).

Descripciones de Propiedades

CameraAttributes attributes 🔗

void set_attributes(value: CameraAttributes)
CameraAttributes get_attributes()

Los CameraAttributes que se utilizarán para esta cámara.

Compositor compositor 🔗

void set_compositor(value: Compositor)
Compositor get_compositor()

El Compositor a utilizar para esta cámara.

int cull_mask = 1048575 🔗

void set_cull_mask(value: int)
int get_cull_mask()

La máscara de recorte (cull mask) que describe cuáles VisualInstance3D.layers son renderizadas por esta cámara. Por defecto, se renderizan las 20 capas visibles para el usuario.

Nota: Dado que la cull_mask permite almacenar 32 capas en total, hay 12 capas adicionales que solo se usan internamente por el motor y no se muestran en el editor. Configurar la cull_mask mediante un script te permite activar o desactivar esas capas reservadas, lo cual puede ser útil para complementos (plugins) del editor.

Para ajustar la cull_mask más fácilmente usando un script, usa get_cull_mask_value() y set_cull_mask_value().

Nota: VoxelGI, SDFGI y LightmapGI siempre tendrán en cuenta todas las capas para determinar qué contribuye a la iluminación global. Si esto es un problema, establece GeometryInstance3D.gi_mode como GeometryInstance3D.GI_MODE_DISABLED para las mallas y Light3D.light_bake_mode como Light3D.BAKE_DISABLED para las luces para excluirlas de la iluminación global.

bool current = false 🔗

void set_current(value: bool)
bool is_current()

Si es true, el Viewport ancestro está utilizando actualmente esta cámara.

Si hay varias cámaras en la escena, una siempre se establecerá como actual. Por ejemplo, si hay dos nodos Camera3D en la escena y solo uno es el actual, establecer el current de una cámara a false hará que la otra cámara pase a ser la actual.

DopplerTracking doppler_tracking = 0 🔗

void set_doppler_tracking(value: DopplerTracking)
DopplerTracking get_doppler_tracking()

Si no está en DOPPLER_TRACKING_DISABLED, esta cámara simulará el efecto Doppler para los objetos que cambien en métodos _process específicos.

Nota: El efecto Doppler solo se escuchará en los AudioStreamPlayer3D si su propiedad AudioStreamPlayer3D.doppler_tracking no está configurada como AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED.

Environment environment 🔗

void set_environment(value: Environment)
Environment get_environment()

El Environment a utilizar para esta cámara.

float far = 4000.0 🔗

void set_far(value: float)
float get_far()

La distancia al límite de recorte lejano (far culling) de esta cámara, relativa a su eje Z local. Valores más altos permiten que la cámara vea más lejos, mientras que disminuir far puede mejorar el rendimiento si esto hace que los objetos se recorten parcial o totalmente.

float fov = 75.0 🔗

void set_fov(value: float)
float get_fov()

El ángulo del campo de visión de la cámara (en grados). Solo es aplicable en modo perspectiva. Dado que keep_aspect bloquea un eje, fov establece el ángulo del campo de visión del otro eje.

Como referencia, el valor predeterminado del campo de visión vertical (75.0) es equivalente a un FOV horizontal de:

~91.31 grados en un viewport de 4:3
~101.67 grados en un viewport de 16:10
~107.51 grados en un viewport de 16:9
~121.63 grados en un viewport de 21:9

Vector2 frustum_offset = Vector2(0, 0) 🔗

void set_frustum_offset(value: Vector2)
Vector2 get_frustum_offset()

El desplazamiento del frustum de la cámara. Esto puede cambiarse desde el valor predeterminado para crear efectos de "frustum inclinado" como el cizallamiento en Y.

Nota: Solo es efectivo si projection es PROJECTION_FRUSTUM.

float h_offset = 0.0 🔗

void set_h_offset(value: float)
float get_h_offset()

El desplazamiento horizontal (X) de la vista de la cámara.

KeepAspect keep_aspect = 1 🔗

void set_keep_aspect_mode(value: KeepAspect)
KeepAspect get_keep_aspect_mode()

El eje a bloquear durante los ajustes de fov/size. Puede ser KEEP_WIDTH o KEEP_HEIGHT.

float near = 0.05 🔗

void set_near(value: float)
float get_near()

La distancia al límite de recorte cercano (near culling) de esta cámara, relativa a su eje Z local. Valores más bajos permiten que la cámara vea objetos más de cerca, pero a costa de perder precisión en todo el rango. Usar valores menores al predeterminado puede causar que aumente el "Z-fighting" (parpadeo de texturas).

ProjectionType projection = 0 🔗

void set_projection(value: ProjectionType)
ProjectionType get_projection()

El modo de proyección de la cámara. En el modo PROJECTION_PERSPECTIVE, la distancia Z de los objetos al espacio local de la cámara escala su tamaño percibido.

float size = 1.0 🔗

void set_size(value: float)
float get_size()

El tamaño de la cámara en metros, medido como el diámetro del ancho o del alto, dependiendo de keep_aspect. Solo es aplicable en los modos orthogonal y frustum.

float v_offset = 0.0 🔗

void set_v_offset(value: float)
float get_v_offset()

El desplazamiento vertical (Y) del viewport de la cámara.

Descripciones de Métodos

void clear_current(enable_next: bool = true) 🔗

Si esta es la cámara actual, dejar de usarla. Si enable_next es true, se solicitará usar la siguiente cámara, si existe.

Projection get_camera_projection() const 🔗

Devuelve la matriz de proyección que esta cámara utiliza para renderizar a su viewport asociado. La cámara debe ser parte del árbol de la escena para funcionar.

RID get_camera_rid() const 🔗

Devuelve el RID de la cámara desde el RenderingServer.

Transform3D get_camera_transform() const 🔗

Devuelve la transformación de la cámara más los desplazamientos verticales (v_offset) y horizontales (h_offset); y cualquier otro ajuste realizado a la posición y orientación de la cámara por las cámaras subclasificadas como XRCamera3D.

bool get_cull_mask_value(layer_number: int) const 🔗

Devuelve si la capa especificada de cull_mask está habilitada, dado un layer_number entre 1 y 20.

Array[Plane] get_frustum() const 🔗

Devuelve los planos del frustum de la cámara en unidades del espacio mundial como un array de Planes en el siguiente orden: cerca, lejos, izquierda, arriba, derecha, abajo. No confundir con frustum_offset.

RID get_pyramid_shape_rid() 🔗

Devuelve el RID de una forma piramidal que abarca el frustum de visión de la cámara, ignorando el plano cercano de la cámara. La punta de la pirámide representa la posición de la cámara.

bool is_position_behind(world_point: Vector3) const 🔗

Devuelve true si la posición dada está detrás de la cámara (la parte azul del diagrama enlazado). Véase este diagrama para obtener una visión general de los métodos de consulta de posición.

Nota: Una posición que devuelva false aún puede estar fuera del campo de visión de la cámara.

bool is_position_in_frustum(world_point: Vector3) const 🔗

Devuelve true si la posición dada está dentro del frustum de la cámara (la parte verde del diagrama enlazado). Véase este diagrama para obtener una visión general de los métodos de consulta de posición.

void make_current() 🔗

Hace que esta cámara sea la cámara actual para el Viewport (ver descripción de la clase). Si el nodo de la cámara está fuera del árbol de escenas, intentará convertirse en actual una vez que se añada.

Vector3 project_local_ray_normal(screen_point: Vector2) const 🔗

Devuelve un vector normal de la ubicación del punto de la pantalla dirigido a lo largo de la cámara. Las cámaras ortogonales están normalizadas. Las cámaras de perspectiva tienen en cuenta la perspectiva, la anchura y la altura de la pantalla, etc.

Vector3 project_position(screen_point: Vector2, z_depth: float) const 🔗

Devuelve el punto 3D en el espacio mundial que se corresponde con la coordenada 2D dada en el rectángulo del Viewport, en un plano que está a la distancia z_depth en la escena, alejado de la cámara.

Vector3 project_ray_normal(screen_point: Vector2) const 🔗

Devuelve un vector normal en el espacio mundial, que es el resultado de proyectar un punto en el rectángulo del Viewport mediante la proyección inversa de la cámara. Esto es útil para lanzar rayos en forma de (origen, normal) para la intersección o selección de objetos.

Vector3 project_ray_origin(screen_point: Vector2) const 🔗

Devuelve una posición 3D en el espacio mundial, que es el resultado de proyectar un punto en el rectángulo del Viewport mediante la proyección inversa de la cámara. Esto es útil para lanzar rayos en forma de (origen, normal) para la intersección o selección de objetos.

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

Según value, activa o desactiva la capa especificada en el cull_mask, dado un layer_number entre 1 y 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) 🔗

Establece la proyección de la cámara en modo ortogonal (véase PROJECTION_ORTHOGONAL), especificando un size, y los planos de recorte z_near y z_far en unidades del espacio mundial.

Como sugerencia, los juegos 3D que parecen 2D a menudo usan esta proyección, con size especificado en píxeles.

void set_perspective(fov: float, z_near: float, z_far: float) 🔗

Establece la proyección de la cámara en modo de perspectiva (véase PROJECTION_PERSPECTIVE), especificando un ángulo fov (campo de visión) en grados, y los planos de recorte z_near y z_far en unidades del espacio mundial.

Vector2 unproject_position(world_point: Vector3) const 🔗

Devuelve la coordenada 2D en el rectángulo del Viewport que corresponde al punto 3D dado en el espacio del mundo.

Nota: Cuando uses esto para posicionar elementos de la interfaz (GUI) sobre una vista 3D, usa is_position_behind() para evitar que aparezcan si el punto 3D está detrás de la cámara:

#Este bloque de código es parte de un script que hereda de Node3D.
# `control` es una referencia a un nodo que hereda de 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)