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

SpriteBase3D

Hereda: GeometryInstance3D < VisualInstance3D < Node3D < Node < Object

Heredado por: AnimatedSprite3D, Sprite3D

Nodo de sprite 2D en un entorno 3D.

Descripción

Un nodo que muestra información de textura 2D en un entorno 3D. Véase también Sprite3D donde se definen muchas otras propiedades.

Propiedades

float

alpha_antialiasing_edge

0.0

AlphaAntiAliasing

alpha_antialiasing_mode

0

AlphaCutMode

alpha_cut

0

float

alpha_hash_scale

1.0

float

alpha_scissor_threshold

0.5

Axis

axis

2

BillboardMode

billboard

0

bool

centered

true

bool

double_sided

true

bool

fixed_size

false

bool

flip_h

false

bool

flip_v

false

Color

modulate

Color(1, 1, 1, 1)

bool

no_depth_test

false

Vector2

offset

Vector2(0, 0)

float

pixel_size

0.01

int

render_priority

0

bool

shaded

false

TextureFilter

texture_filter

3

bool

transparent

true

Métodos

TriangleMesh

generate_triangle_mesh() const

bool

get_draw_flag(flag: DrawFlags) const

Rect2

get_item_rect() const

void

set_draw_flag(flag: DrawFlags, enabled: bool)

Enumeraciones

enum DrawFlags: 🔗

DrawFlags FLAG_TRANSPARENT = 0

Si se fija, la transparencia de la textura y la opacidad se utilizan para hacer invisibles esas partes del sprite.

DrawFlags FLAG_SHADED = 1

Si se ajusta, las luces del entorno afectan al sprite.

DrawFlags FLAG_DOUBLE_SIDED = 2

Si está activado, la textura también se puede ver desde atrás. Si no, la textura es invisible cuando se mira desde atrás.

DrawFlags FLAG_DISABLE_DEPTH_TEST = 3

Desactiva la prueba de profundidad, así que este objeto se dibuja encima de todos los demás. Sin embargo, los objetos dibujados después de él en el orden de dibujo pueden cubrirlo.

DrawFlags FLAG_FIXED_SIZE = 4

La etiqueta se escala según la profundidad para que siempre aparezca del mismo tamaño en la pantalla.

DrawFlags FLAG_MAX = 5

Representa el tamaño del enum DrawFlags.

enum AlphaCutMode: 🔗

AlphaCutMode ALPHA_CUT_DISABLED = 0

Este modo realiza una mezcla alfa estándar. Puede mostrar áreas translúcidas, pero los problemas de ordenación de la transparencia pueden ser visibles cuando varios materiales transparentes se superponen.

AlphaCutMode ALPHA_CUT_DISCARD = 1

Este modo solo permite píxeles totalmente transparentes o totalmente opacos. Los bordes duros serán visibles a menos que se active alguna forma de antialiasing en el espacio de la pantalla (véase ProjectSettings.rendering/anti_aliasing/quality/screen_space_aa). En el lado bueno, este modo no sufre problemas de ordenación de la transparencia cuando varios materiales transparentes se superponen. Este modo también se conoce como prueba alfa o transparencia de 1 bit.

AlphaCutMode ALPHA_CUT_OPAQUE_PREPASS = 2

Este modo dibuja píxeles completamente opacos en el pre-pase de profundidad. Esto es más lento que ALPHA_CUT_DISABLED o ALPHA_CUT_DISCARD, pero permite mostrar áreas translúcidas y bordes suaves mientras se usa la ordenación adecuada.

AlphaCutMode ALPHA_CUT_HASH = 3

Este modo corta todos los valores por debajo de un umbral espacialmente determinista; el resto permanecerá opaco.

Descripciones de Propiedades

float alpha_antialiasing_edge = 0.0 🔗

  • void set_alpha_antialiasing_edge(value: float)

  • float get_alpha_antialiasing_edge()

Threshold at which antialiasing will be applied on the alpha channel.

AlphaAntiAliasing alpha_antialiasing_mode = 0 🔗

El tipo de antialiasing alfa que se aplicará.

AlphaCutMode alpha_cut = 0 🔗

El modo de corte alfa a utilizar para el sprite.

float alpha_hash_scale = 1.0 🔗

  • void set_alpha_hash_scale(value: float)

  • float get_alpha_hash_scale()

The hashing scale for Alpha Hash. Recommended values between 0 and 2.

float alpha_scissor_threshold = 0.5 🔗

  • void set_alpha_scissor_threshold(value: float)

  • float get_alpha_scissor_threshold()

Umbral en el que el alpha scissor descartará los valores.

Axis axis = 2 🔗

  • void set_axis(value: Axis)

  • Axis get_axis()

La dirección en la que se orienta el frente de la textura.

BillboardMode billboard = 0 🔗

El modo billboard a usar para el sprite.

Nota: Cuando el billboard está habilitado y el material también proyecta sombras, los billboards se orientarán hacia la cámara en la escena al renderizar sombras. En escenas con múltiples cámaras, la sombra deseada no puede ser determinada y esto resultará en un comportamiento indefinido. Véase GitHub Pull Request #72638 para más detalles.

bool centered = true 🔗

  • void set_centered(value: bool)

  • bool is_centered()

Si es true, la textura se centrará.

bool double_sided = true 🔗

Si es true, la textura también se puede ver desde atrás, si false, es invisible cuando se mira desde atrás.

bool fixed_size = false 🔗

Si es true, la textura se renderiza al mismo tamaño independientemente de la distancia. El tamaño de la textura en pantalla es el mismo que si la cámara estuviera a 1.0 unidades de distancia del origen de la textura, independientemente de la distancia real de la cámara. El campo de visión de la Camera3D (o Camera3D.size en modo ortogonal/frustum) todavía afecta el tamaño en que se dibuja el sprite.

bool flip_h = false 🔗

  • void set_flip_h(value: bool)

  • bool is_flipped_h()

Si es true, la textura se voltea horizontalmente.

bool flip_v = false 🔗

  • void set_flip_v(value: bool)

  • bool is_flipped_v()

Si es true, la textura se voltea verticalmente.

Color modulate = Color(1, 1, 1, 1) 🔗

  • void set_modulate(value: Color)

  • Color get_modulate()

Un valor de color utilizado para multiplicar los colores de la textura. Puede usarse para dar color de ambiente o para simular el color de la luz ambiental.

Nota: A diferencia de CanvasItem.modulate para 2D, los colores con valores superiores a 1.0 (sobresaturados) no son compatibles.

Nota: Si se define un GeometryInstance3D.material_override en el SpriteBase3D, el material de sobrescritura debe configurarse para tener en cuenta los colores de los vértices para el albedo. De lo contrario, el color definido en modulate será ignorado. Para un BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo debe ser true. Para un ShaderMaterial, ALBEDO *= COLOR.rgb; debe insertarse en la función fragment() del shader.

bool no_depth_test = false 🔗

Si es true, la prueba de profundidad está desactivada y el objeto se dibujará en orden de renderizado.

Vector2 offset = Vector2(0, 0) 🔗

El desplazamiento de dibujo de la textura.

Nota: Cuando aumentas offset.y en Sprite3D, el sprite se mueve hacia arriba en el espacio mundial (es decir, +Y es hacia arriba).

float pixel_size = 0.01 🔗

  • void set_pixel_size(value: float)

  • float get_pixel_size()

El tamaño del ancho de un píxel en el sprite para escalarlo en 3D.

int render_priority = 0 🔗

  • void set_render_priority(value: int)

  • int get_render_priority()

Sets the render priority for the sprite. Higher priority objects will be sorted in front of lower priority objects.

Note: This only applies if alpha_cut is set to ALPHA_CUT_DISABLED (default value).

Note: This only applies to sorting of transparent objects. This will not impact how transparent objects are sorted relative to opaque objects. This is because opaque objects are not sorted, while transparent objects are sorted from back to front (subject to priority).

bool shaded = false 🔗

Si es true, la Light3D en el Environment tiene efectos en el sprite.

TextureFilter texture_filter = 3 🔗

Marcas de filtro para la textura.

Nota: El filtrado lineal puede causar artefactos alrededor de los bordes, que son especialmente notables en texturas opacas. Para evitar esto, utiliza texturas con colores transparentes o idénticos alrededor de los bordes.

bool transparent = true 🔗

Si es true, la transparencia de la textura y la opacidad se usan para hacer invisibles estas partes del sprite.

Descripciones de Métodos

TriangleMesh generate_triangle_mesh() const 🔗

Devuelve una TriangleMesh con los vértices del sprite siguiendo su configuración actual (como su axis y pixel_size).

bool get_draw_flag(flag: DrawFlags) const 🔗

Devuelve el valor de la flag especificada.

Rect2 get_item_rect() const 🔗

Devuelve el rectángulo que representa a este sprite.

void set_draw_flag(flag: DrawFlags, enabled: bool) 🔗

Si es true, la bandera especificada será activada.