Node3D

Hereda: Node < Object

Heredado por: AudioListener3D, AudioStreamPlayer3D, BoneAttachment3D, Camera3D, CollisionObject3D, CollisionPolygon3D, CollisionShape3D, GridMap, ImporterMeshInstance3D, Joint3D, LightmapProbe, Marker3D, NavigationLink3D, NavigationObstacle3D, NavigationRegion3D, OpenXRCompositionLayer, OpenXRHand, OpenXRRenderModel, OpenXRRenderModelManager, Path3D, PathFollow3D, RayCast3D, RemoteTransform3D, ShapeCast3D, Skeleton3D, SkeletonModifier3D, SpringArm3D, SpringBoneCollision3D, VehicleWheel3D, VisualInstance3D, XRFaceModifier3D, XRNode3D, XROrigin3D

Objeto base en el espacio 3D, del que heredan todos los nodos 3D.

Descripción

The Node3D node is the base representation of a node in 3D space. All other 3D nodes inherit from this class.

Affine operations (translation, rotation, scale) are calculated in the coordinate system relative to the parent, unless the Node3D's top_level is true. In this coordinate system, affine operations correspond to direct affine operations on the Node3D's transform. The term parent space refers to this coordinate system. The coordinate system that is attached to the Node3D itself is referred to as object-local coordinate system, or local space.

Note: Unless otherwise specified, all methods that need angle parameters must receive angles in radians. To convert degrees to radians, use @GlobalScope.deg_to_rad().

Note: In Godot 3 and older, Node3D was named Spatial.

Tutoriales

Propiedades

Basis	basis
Basis	global_basis
Vector3	global_position
Vector3	global_rotation
Vector3	global_rotation_degrees
Transform3D	global_transform
Vector3	position	`Vector3(0, 0, 0)`
Quaternion	quaternion
Vector3	rotation	`Vector3(0, 0, 0)`
Vector3	rotation_degrees
RotationEditMode	rotation_edit_mode	`0`
EulerOrder	rotation_order	`2`
Vector3	scale	`Vector3(1, 1, 1)`
bool	top_level	`false`
Transform3D	transform	`Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0)`
NodePath	visibility_parent	`NodePath("")`
bool	visible	`true`

Métodos

void	add_gizmo(gizmo: Node3DGizmo)
void	clear_gizmos()
void	clear_subgizmo_selection()
void	force_update_transform()
Array[Node3DGizmo]	get_gizmos() const
Transform3D	get_global_transform_interpolated()
Node3D	get_parent_node_3d() const
World3D	get_world_3d() const
void	global_rotate(axis: Vector3, angle: float)
void	global_scale(scale: Vector3)
void	global_translate(offset: Vector3)
void	hide()
bool	is_local_transform_notification_enabled() const
bool	is_scale_disabled() const
bool	is_transform_notification_enabled() const
bool	is_visible_in_tree() const
void	look_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false)
void	look_at_from_position(position: Vector3, target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false)
void	orthonormalize()
void	rotate(axis: Vector3, angle: float)
void	rotate_object_local(axis: Vector3, angle: float)
void	rotate_x(angle: float)
void	rotate_y(angle: float)
void	rotate_z(angle: float)
void	scale_object_local(scale: Vector3)
void	set_disable_scale(disable: bool)
void	set_identity()
void	set_ignore_transform_notification(enabled: bool)
void	set_notify_local_transform(enable: bool)
void	set_notify_transform(enable: bool)
void	set_subgizmo_selection(gizmo: Node3DGizmo, id: int, transform: Transform3D)
void	show()
Vector3	to_global(local_point: Vector3) const
Vector3	to_local(global_point: Vector3) const
void	translate(offset: Vector3)
void	translate_object_local(offset: Vector3)
void	update_gizmos()

Señales

visibility_changed() 🔗

Se emite cuando la visibilidad de este nodo cambia (véase visible y is_visible_in_tree()).

Esta señal se emite después de la notificación relacionada NOTIFICATION_VISIBILITY_CHANGED.

Enumeraciones

enum RotationEditMode: 🔗

RotationEditMode ROTATION_EDIT_MODE_EULER = 0

La rotación se edita utilizando un Vector3 en ángulos de Euler.

RotationEditMode ROTATION_EDIT_MODE_QUATERNION = 1

La rotación se edita utilizando un Quaternion.

RotationEditMode ROTATION_EDIT_MODE_BASIS = 2

La rotación se edita utilizando una Basis. En este modo, los ejes sin procesar de basis se pueden modificar libremente, pero la propiedad scale no está disponible.

Constantes

NOTIFICATION_TRANSFORM_CHANGED = 2000 🔗

Notificación recibida cuando la global_transform de este nodo cambia, si is_transform_notification_enabled() es true. Véase también set_notify_transform().

Nota: La mayoría de los nodos 3D, como VisualInstance3D o CollisionObject3D, habilitan esto automáticamente para que funcionen correctamente.

Nota: En el editor, los nodos propagarán esta notificación a sus hijos si se adjunta un gizmo (véase add_gizmo()).

NOTIFICATION_ENTER_WORLD = 41 🔗

Notificación recibida cuando este nodo se registra en un nuevo World3D (véase get_world_3d()).

NOTIFICATION_EXIT_WORLD = 42 🔗

Notificación recibida cuando este nodo se da de baja del World3D actual (véase get_world_3d()).

NOTIFICATION_VISIBILITY_CHANGED = 43 🔗

Notification received when this node's visibility changes (see visible and is_visible_in_tree()).

This notification is received before the related visibility_changed signal.

NOTIFICATION_LOCAL_TRANSFORM_CHANGED = 44 🔗

Notificación recibida cuando la transform de este nodo cambia, si is_local_transform_notification_enabled() es true. Esto no se recibe cuando la transform de un Node3D padre cambia. Véase también set_notify_local_transform().

Nota: Algunos nodos 3D como CSGShape3D o CollisionShape3D habilitan esto automáticamente para que funcionen correctamente.

Descripciones de Propiedades

Basis basis 🔗

void set_basis(value: Basis)
Basis get_basis()

Basis of the transform property. Represents the rotation, scale, and shear of this node in parent space (relative to the parent node).

Basis global_basis 🔗

void set_global_basis(value: Basis)
Basis get_global_basis()

Basis of the global_transform property. Represents the rotation, scale, and shear of this node in global space (relative to the world).

Note: If the node is not inside the tree, getting this property fails and returns Basis.IDENTITY.

Vector3 global_position 🔗

void set_global_position(value: Vector3)
Vector3 get_global_position()

Posición global (traslación) de este nodo en el espacio global (relativo al mundo). Esto es equivalente al Transform3D.origin de la global_transform.

Nota: Si el nodo no está dentro del árbol, obtener esta propiedad falla y devuelve Vector3.ZERO.

Vector3 global_rotation 🔗

void set_global_rotation(value: Vector3)
Vector3 get_global_rotation()

Rotación global de este nodo como ángulos de Euler, en radianes y en el espacio global (relativo al mundo). Este valor se obtiene de la rotación de global_basis.

El Vector3.x es el ángulo alrededor del eje X global (cabeceo);
El Vector3.y es el ángulo alrededor del eje Y global (guiñada);
El Vector3.z es el ángulo alrededor del eje Z global (balanceo).

Nota: A diferencia de rotation, esta propiedad siempre sigue la convención YXZ (@GlobalScope.EULER_ORDER_YXZ).

Nota: Si el nodo no está dentro del árbol, obtener esta propiedad falla y devuelve Vector3.ZERO.

Vector3 global_rotation_degrees 🔗

void set_global_rotation_degrees(value: Vector3)
Vector3 get_global_rotation_degrees()

La global_rotation de este nodo, en grados en lugar de radianes.

Nota: Si el nodo no está dentro del árbol, obtener esta propiedad falla y devuelve Vector3.ZERO.

Transform3D global_transform 🔗

void set_global_transform(value: Transform3D)
Transform3D get_global_transform()

La transformación de este nodo, en el espacio global (relativo al mundo). Contiene y representa la global_position, la global_rotation y la escala global de este nodo.

Nota: Si el nodo no está dentro del árbol, obtener esta propiedad falla y devuelve Transform3D.IDENTITY.

Vector3 position = Vector3(0, 0, 0) 🔗

void set_position(value: Vector3)
Vector3 get_position()

Posición (traslación) de este nodo en el espacio padre (relativo al nodo padre). Esto es equivalente al Transform3D.origin de transform.

Quaternion quaternion 🔗

void set_quaternion(value: Quaternion)
Quaternion get_quaternion()

Rotación de este nodo representada como un Quaternion en el espacio padre (relativo al nodo padre). Este valor se obtiene de la rotación de basis.

Nota: Los cuaterniones son mucho más adecuados para las matemáticas 3D, pero son menos intuitivos. Establecer esta propiedad puede ser útil para la interpolación (véase Quaternion.slerp()).

Vector3 rotation = Vector3(0, 0, 0) 🔗

void set_rotation(value: Vector3)
Vector3 get_rotation()

Rotation of this node as Euler angles, in radians and in parent space (relative to the parent node). This value is obtained from basis's rotation.

The Vector3.x is the angle around the local X axis (pitch);
The Vector3.y is the angle around the local Y axis (yaw);
The Vector3.z is the angle around the local Z axis (roll).

The order of each consecutive rotation can be changed with rotation_order (see EulerOrder constants). By default, the YXZ convention is used (@GlobalScope.EULER_ORDER_YXZ).

Note: This property is edited in degrees in the inspector. If you want to use degrees in a script, use rotation_degrees.

Vector3 rotation_degrees 🔗

void set_rotation_degrees(value: Vector3)
Vector3 get_rotation_degrees()

The rotation of this node, in degrees instead of radians.

Note: This is not the property available in the Inspector dock.

RotationEditMode rotation_edit_mode = 0 🔗

void set_rotation_edit_mode(value: RotationEditMode)
RotationEditMode get_rotation_edit_mode()

How this node's rotation and scale are displayed in the Inspector dock.

EulerOrder rotation_order = 2 🔗

void set_rotation_order(value: EulerOrder)
EulerOrder get_rotation_order()

El orden de rotación de los ejes de la propiedad rotation. La orientación final se calcula girando alrededor de los ejes X, Y y Z locales en este orden.

Vector3 scale = Vector3(1, 1, 1) 🔗

void set_scale(value: Vector3)
Vector3 get_scale()

Scale of this node in local space (relative to this node). This value is obtained from basis's scale.

Note: The behavior of some 3D node types is not affected by this property. These include Light3D, Camera3D, AudioStreamPlayer3D, and more.

Warning: The scale's components must either be all positive or all negative, and not exactly 0.0. Otherwise, it won't be possible to obtain the scale from the basis. This may cause the intended scale to be lost when reloaded from disk, and potentially other unstable behavior.

bool top_level = false 🔗

void set_as_top_level(value: bool)
bool is_set_as_top_level()

If true, the node does not inherit its transformations from its parent. As such, node transformations will only be in global space, which also means that global_transform and transform will be identical.

Transform3D transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗

void set_transform(value: Transform3D)
Transform3D get_transform()

La transformación local de este nodo, en el espacio padre (relativo al nodo padre). Contiene y representa la position, la rotation y la scale de este nodo.

NodePath visibility_parent = NodePath("") 🔗

void set_visibility_parent(value: NodePath)
NodePath get_visibility_parent()

Ruta al padre del rango de visibilidad para este nodo y sus descendientes. El padre de visibilidad debe ser un GeometryInstance3D.

Cualquier instancia visual solo será visible si el padre de visibilidad (y todos sus ancestros de visibilidad) está oculto por estar más cerca de la cámara que su propio GeometryInstance3D.visibility_range_begin. Los nodos ocultos a través de la propiedad visible se eliminan esencialmente del árbol de dependencias de visibilidad, por lo que las instancias dependientes no tendrán en cuenta el nodo oculto ni sus descendientes.

bool visible = true 🔗

void set_visible(value: bool)
bool is_visible()

Si es true, este nodo puede ser visible. El nodo solo se renderiza cuando todos sus ancestros son visibles también. Esto significa que is_visible_in_tree() debe devolver true.

Descripciones de Métodos

void add_gizmo(gizmo: Node3DGizmo) 🔗

Adjunta el gizmo dado a este nodo. Solo funciona en el editor.

Nota: gizmo debería ser un EditorNode3DGizmo. El tipo de argumento es Node3DGizmo para evitar depender de las clases del editor en Node3D.

void clear_gizmos() 🔗

Limpia todos los objetos EditorNode3DGizmo adjuntos a este nodo. Solo funciona en el editor.

void clear_subgizmo_selection() 🔗

Deselecciona todos los subgizmos para este nodo. Útil para llamar cuando el subgizmo seleccionado puede que ya no exista después de un cambio de propiedad. Solo funciona en el editor.

void force_update_transform() 🔗

Forces the node's global_transform to update, by sending NOTIFICATION_TRANSFORM_CHANGED. Fails if the node is not inside the tree.

Note: For performance reasons, transform changes are usually accumulated and applied once at the end of the frame. The update propagates through Node3D children, as well. Therefore, use this method only when you need an up-to-date transform (such as during physics operations).

Array[Node3DGizmo] get_gizmos() const 🔗

Returns all the EditorNode3DGizmo objects attached to this node. Only works in the editor.

Transform3D get_global_transform_interpolated() 🔗

When using physics interpolation, there will be circumstances in which you want to know the interpolated (displayed) transform of a node rather than the standard transform (which may only be accurate to the most recent physics tick).

This is particularly important for frame-based operations that take place in Node._process(), rather than Node._physics_process(). Examples include Camera3Ds focusing on a node, or finding where to fire lasers from on a frame rather than physics tick.

Note: This function creates an interpolation pump on the Node3D the first time it is called, which can respond to physics interpolation resets. If you get problems with "streaking" when initially following a Node3D, be sure to call get_global_transform_interpolated() at least once before resetting the Node3D physics interpolation.

Node3D get_parent_node_3d() const 🔗

Devuelve el Node3D padre que afecta directamente a la global_transform de este nodo. Devuelve null si no existe un padre, si el padre no es un Node3D, o si top_level es true.

Nota: Este método no siempre es equivalente a Node.get_parent(), que no tiene en cuenta top_level.

World3D get_world_3d() const 🔗

Devuelve el World3D al que está registrado este nodo.

Normalmente, este es el mismo que el mundo utilizado por el viewport de este nodo (véase Node.get_viewport() y Viewport.find_world_3d()).

void global_rotate(axis: Vector3, angle: float) 🔗

Rota la global_basis de este nodo alrededor del axis global por el angle dado, en radianes. Esta operación se calcula en el espacio global (relativo al mundo) y conserva la global_position.

void global_scale(scale: Vector3) 🔗

Escala la global_basis de este nodo por el factor de scale dado. Esta operación se calcula en el espacio global (relativo al mundo) y conserva la global_position.

Nota: Este método no debe confundirse con la propiedad scale.

void global_translate(offset: Vector3) 🔗

Añade la traslación offset dada a la global_position del nodo en el espacio global (relativo al mundo).

void hide() 🔗

Prevents this node from being rendered. Equivalent to setting visible to false. This is the opposite of show().

bool is_local_transform_notification_enabled() const 🔗

Returns true if the node receives NOTIFICATION_LOCAL_TRANSFORM_CHANGED whenever transform changes. This is enabled with set_notify_local_transform().

bool is_scale_disabled() const 🔗

Devuelve true si la global_transform de este nodo se ortonormaliza automáticamente. Esto hace que este nodo no aparezca distorsionado, como si su escala global estuviera establecida en Vector3.ONE (o su contraparte negativa). Véase también set_disable_scale() y orthonormalize().

Nota: transform no se ve afectada por esta configuración.

bool is_transform_notification_enabled() const 🔗

Devuelve true si el nodo recibe NOTIFICATION_TRANSFORM_CHANGED cada vez que global_transform cambia. Esto se habilita con set_notify_transform().

bool is_visible_in_tree() const 🔗

Devuelve true si este nodo está dentro del árbol de escenas y si la propiedad visible es true para este nodo y todos sus ancestros Node3D en secuencia. Un ancestro de cualquier otro tipo (como Node o Node2D) rompe la secuencia. Véase también Node.get_parent().

Nota: Este método no puede tener en cuenta VisualInstance3D.layers, por lo que incluso si este método devuelve true, es posible que el nodo no se renderice.

void look_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) 🔗

Rota el nodo de forma que el eje frontal local (-Z, Vector3.FORWARD) apunte hacia la posición target. Esta operación se calcula en el espacio global (relativo al mundo).

El eje local hacia arriba (+Y) apunta lo más cerca posible al vector up, manteniéndose perpendicular al eje frontal local. La transformación resultante es ortogonal y la escala se conserva. El escalado no uniforme puede no funcionar correctamente.

La posición target no puede ser la misma que la posición del nodo, el vector up no puede ser Vector3.ZERO. Además, la dirección desde la posición del nodo a la posición target no puede ser paralela al vector up, para evitar una rotación no deseada alrededor del eje Z local.

Si use_model_front es true, el eje +Z (frontal del activo) se trata como frontal (implica que +X es la izquierda) y apunta hacia la posición target. Por defecto, el eje -Z (frontal de la cámara) se trata como frontal (implica que +X es la derecha).

Nota: Este método falla si el nodo no está en el árbol de escenas. Si es necesario, usa look_at_from_position() en su lugar.

void look_at_from_position(position: Vector3, target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) 🔗

Mueve el nodo a la position especificada y luego rota el nodo para que apunte hacia la posición target, similar a look_at(). Esta operación se calcula en el espacio global (relativo al mundo).

void orthonormalize() 🔗

Ortonormaliza la basis de este nodo. Este método establece la scale de este nodo a Vector3.ONE (o su contraparte negativa), pero conserva la position y la rotation. Véase también Transform3D.orthonormalized().

void rotate(axis: Vector3, angle: float) 🔗

Rota la basis de este nodo alrededor del axis por el angle dado, en radianes. Esta operación se calcula en el espacio padre (relativo al padre) y conserva la position.

void rotate_object_local(axis: Vector3, angle: float) 🔗

Rota la basis de este nodo alrededor del axis por el angle dado, en radianes. Esta operación se calcula en el espacio local (relativo a este nodo) y conserva la position.

void rotate_x(angle: float) 🔗

Rota la basis de este nodo alrededor del eje X por el angle dado, en radianes. Esta operación se calcula en el espacio padre (relativo al padre) y conserva la position.

void rotate_y(angle: float) 🔗

Rota la basis de este nodo alrededor del eje Y por el angle dado, en radianes. Esta operación se calcula en el espacio padre (relativo al padre) y conserva la position.

void rotate_z(angle: float) 🔗

Rota la basis de este nodo alrededor del eje Z por el angle dado, en radianes. Esta operación se calcula en el espacio padre (relativo al padre) y conserva la position.

void scale_object_local(scale: Vector3) 🔗

Escala la basis de este nodo por el factor de scale dado. Esta operación se calcula en el espacio local (relativo a este nodo) y conserva la position.

void set_disable_scale(disable: bool) 🔗

Si es true, la global_transform de este nodo se ortonormaliza automáticamente. Esto hace que este nodo no aparezca distorsionado, como si su escala global estuviera establecida en Vector3.ONE (o su contraparte negativa). Véase también is_scale_disabled() y orthonormalize().

Nota: transform no se ve afectada por esta configuración.

void set_identity() 🔗

Establece la transform de este nodo a Transform3D.IDENTITY, lo que restablece todas las transformaciones en el espacio padre (position, rotation y scale).

void set_ignore_transform_notification(enabled: bool) 🔗

Si es true, el nodo no recibirá NOTIFICATION_TRANSFORM_CHANGED ni NOTIFICATION_LOCAL_TRANSFORM_CHANGED.

Puede ser útil llamar a este método al manejar estas notificaciones para evitar la recursión infinita.

void set_notify_local_transform(enable: bool) 🔗

Si es true, el nodo recibirá NOTIFICATION_LOCAL_TRANSFORM_CHANGED cada vez que cambie transform.

Nota: Algunos nodos 3D, como CSGShape3D o CollisionShape3D, habilitan esto automáticamente para que funcionen correctamente.

void set_notify_transform(enable: bool) 🔗

Si es true, el nodo recibirá NOTIFICATION_TRANSFORM_CHANGED cada vez que global_transform cambie.

Nota: La mayoría de los nodos 3D como VisualInstance3D o CollisionObject3D habilitan esto automáticamente para que funcionen correctamente.

Nota: En el editor, los nodos propagarán esta notificación a sus hijos si se adjunta un gizmo (véase add_gizmo()).

void set_subgizmo_selection(gizmo: Node3DGizmo, id: int, transform: Transform3D) 🔗

Selecciona el subgizmo del gizmo con el id dado y establece su transformación. Solo funciona en el editor.

Nota: El objeto gizmo normalmente sería una instancia de EditorNode3DGizmo, pero el tipo de argumento se mantiene genérico para evitar crear una dependencia de las clases del editor en Node3D.

void show() 🔗

Permite que este nodo se renderice. Equivalente a establecer visible como true. Esto es lo opuesto a hide().

Vector3 to_global(local_point: Vector3) const 🔗

Devuelve el local_point convertido del espacio local de este nodo al espacio global. Esto es lo opuesto a to_local().

Vector3 to_local(global_point: Vector3) const 🔗

Devuelve el global_point convertido del espacio global al espacio local de este nodo. Esto es lo opuesto a to_global().

void translate(offset: Vector3) 🔗

Adds the given translation offset to the node's position, in local space (relative to this node).

Note: Prefer using translate_object_local(), instead, as this method may be changed in a future release.

Note: Despite the naming convention, this operation is not calculated in parent space for compatibility reasons. To translate in parent space, add offset to the position (node_3d.position += offset).

void translate_object_local(offset: Vector3) 🔗

Añade la traslación offset dada a la posición del nodo, en el espacio local (relativo a este nodo).

void update_gizmos() 🔗

Actualiza todos los objetos EditorNode3DGizmo adjuntos a este nodo. Solo funciona en el editor.