Image

Hereda: Resource < RefCounted < Object

Tipo de datos de imagen.

Descripción

El tipo de datos de imagen nativa. Contiene datos de imagen que pueden convertirse en una ImageTexture y proporciona métodos de procesamiento de imágenes de uso común. El ancho y el alto máximos para una Image son MAX_WIDTH y MAX_HEIGHT.

Una Image no se puede asignar directamente a una propiedad de textura de un objeto (como Sprite2D.texture), y primero debe convertirse manualmente en una ImageTexture.

Nota: El tamaño máximo de imagen es de 16384×16384 píxeles debido a las limitaciones del hardware de gráficos. Es posible que las imágenes más grandes no se importen.

Tutoriales

Propiedades

Dictionary

data

{ "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 }

Métodos

void	adjust_bcs(brightness: float, contrast: float, saturation: float)
void	blend_rect(src: Image, src_rect: Rect2i, dst: Vector2i)
void	blend_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i)
void	blit_rect(src: Image, src_rect: Rect2i, dst: Vector2i)
void	blit_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i)
void	bump_map_to_normal_map(bump_scale: float = 1.0)
void	clear_mipmaps()
Error	compress(mode: CompressMode, source: CompressSource = 0, astc_format: ASTCFormat = 0)
Error	compress_from_channels(mode: CompressMode, channels: UsedChannels, astc_format: ASTCFormat = 0)
Dictionary	compute_image_metrics(compared_image: Image, use_luma: bool)
void	convert(format: Format)
void	copy_from(src: Image)
Image	create(width: int, height: int, use_mipmaps: bool, format: Format) static
Image	create_empty(width: int, height: int, use_mipmaps: bool, format: Format) static
Image	create_from_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) static
void	crop(width: int, height: int)
Error	decompress()
AlphaMode	detect_alpha() const
UsedChannels	detect_used_channels(source: CompressSource = 0) const
void	fill(color: Color)
void	fill_rect(rect: Rect2i, color: Color)
void	fix_alpha_edges()
void	flip_x()
void	flip_y()
Error	generate_mipmaps(renormalize: bool = false)
PackedByteArray	get_data() const
int	get_data_size() const
Format	get_format() const
int	get_height() const
int	get_mipmap_count() const
int	get_mipmap_offset(mipmap: int) const
Color	get_pixel(x: int, y: int) const
Color	get_pixelv(point: Vector2i) const
Image	get_region(region: Rect2i) const
Vector2i	get_size() const
Rect2i	get_used_rect() const
int	get_width() const
bool	has_mipmaps() const
bool	is_compressed() const
bool	is_empty() const
bool	is_invisible() const
void	linear_to_srgb()
Error	load(path: String)
Error	load_bmp_from_buffer(buffer: PackedByteArray)
Error	load_dds_from_buffer(buffer: PackedByteArray)
Image	load_from_file(path: String) static
Error	load_jpg_from_buffer(buffer: PackedByteArray)
Error	load_ktx_from_buffer(buffer: PackedByteArray)
Error	load_png_from_buffer(buffer: PackedByteArray)
Error	load_svg_from_buffer(buffer: PackedByteArray, scale: float = 1.0)
Error	load_svg_from_string(svg_str: String, scale: float = 1.0)
Error	load_tga_from_buffer(buffer: PackedByteArray)
Error	load_webp_from_buffer(buffer: PackedByteArray)
void	normal_map_to_xy()
void	premultiply_alpha()
void	resize(width: int, height: int, interpolation: Interpolation = 1)
void	resize_to_po2(square: bool = false, interpolation: Interpolation = 1)
Image	rgbe_to_srgb()
void	rotate_90(direction: ClockDirection)
void	rotate_180()
Error	save_dds(path: String) const
PackedByteArray	save_dds_to_buffer() const
Error	save_exr(path: String, grayscale: bool = false) const
PackedByteArray	save_exr_to_buffer(grayscale: bool = false) const
Error	save_jpg(path: String, quality: float = 0.75) const
PackedByteArray	save_jpg_to_buffer(quality: float = 0.75) const
Error	save_png(path: String) const
PackedByteArray	save_png_to_buffer() const
Error	save_webp(path: String, lossy: bool = false, quality: float = 0.75) const
PackedByteArray	save_webp_to_buffer(lossy: bool = false, quality: float = 0.75) const
void	set_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray)
void	set_pixel(x: int, y: int, color: Color)
void	set_pixelv(point: Vector2i, color: Color)
void	shrink_x2()
void	srgb_to_linear()

Enumeraciones

enum Format: 🔗

Format FORMAT_L8 = 0

Formato de textura con una única profundidad de 8 bits que representa la luminancia.

Format FORMAT_LA8 = 1

Formato de textura OpenGL con dos valores, luminancia y alfa, cada uno almacenado con 8 bits.

Format FORMAT_R8 = 2

Formato de textura OpenGL RED con un solo componente y una profundidad de bits de 8.

Format FORMAT_RG8 = 3

Formato de textura OpenGL RG con dos componentes y una profundidad de bits de 8 para cada uno.

Format FORMAT_RGB8 = 4

Formato de textura OpenGL RGB con tres componentes, cada uno con una profundidad de 8 bits.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_RGBA8 = 5

Formato de textura OpenGL RGB con tres componentes, cada uno con una profundidad de 8 bits.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_RGBA4444 = 6

Formato de textura OpenGL RGBA con cuatro componentes, cada uno con una profundidad de bits de 4.

Format FORMAT_RGB565 = 7

Formato de textura OpenGL RGB con tres componentes. El rojo y azul tienen una profundidad de bits de 5, y el verde tiene una profundidad de bits de 6.

Format FORMAT_RF = 8

Formato de textura OpenGL GL_R32F donde hay un componente, un valor de 32 bits de punto flotante.

Format FORMAT_RGF = 9

Formato de textura OpenGL GL_RG32F donde hay dos componentes, cada uno con valores de 32 bits de real.

Format FORMAT_RGBF = 10

Formato de textura OpenGL GL_RGB32F donde hay tres componentes, cada uno con valores de 32 bits real.

Format FORMAT_RGBAF = 11

Formato de textura OpenGL GL_RGBA32F donde hay cuatro componentes, cada uno con valores de 32 bits real.

Format FORMAT_RH = 12

Formato de textura OpenGL GL_R16F donde hay un componente, un valor de punto flotante de 16 bits de "media precisión".

Format FORMAT_RGH = 13

Formato de textura OpenGL GL_RG16F donde hay dos componentes, cada uno un valor de punto flotante de 16 bits de "media precisión".

Format FORMAT_RGBH = 14

Formato de textura OpenGL GL_RGB16F donde hay tres componentes, cada uno de ellos un valor de punto flotante de "media precisión" de 16 bits.

Format FORMAT_RGBAH = 15

Formato de textura OpenGL GL_RGBA16F donde hay cuatro componentes, cada uno de ellos un valor de punto flotante de "media precisión" de 16 bits.

Format FORMAT_RGBE9995 = 16

Un formato especial de textura OpenGL donde los tres componentes de color tienen 9 bits de precisión y los tres comparten un único exponente de 5 bits.

Format FORMAT_DXT1 = 17

El formato de textura S3TC que utiliza la Compresión de Bloque 1, y es la variación más pequeña de S3TC, sólo proporciona 1 bit de datos alfa y de color siendo premultiplicado con alfa.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_DXT3 = 18

El formato de textura S3TC que utiliza la Compresión de Bloque 2, y los datos de color se interpretan como que no han sido premultiplicados por el alfa. Es muy adecuado para imágenes con transiciones alfa nítidas entre áreas translúcidas y opacas.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_DXT5 = 19

El formato de textura S3TC también conocido como Compresión de Bloque 3 o BC3 que contiene 64 bits de datos de canal alfa seguidos de 64 bits de datos de color codificados en DXT1. Los datos de color no son premultiplicados por el alfa, igual que el DXT3. DXT5 generalmente produce resultados superiores para gradientes transparentes en comparación con DXT3.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_RGTC_R = 20

Formato de textura que utiliza Compresión de textura rojo-verde, normalizando los datos del canal rojo utilizando el mismo algoritmo de compresión que DXT5 utiliza para el canal alfa.

Format FORMAT_RGTC_RG = 21

Formato de textura que utiliza Compresión de textura rojo-verde, normalizando los datos de los canales rojo y verde utilizando el mismo algoritmo de compresión que DXT5 utiliza para el canal alfa.

Format FORMAT_BPTC_RGBA = 22

Formato de textura que utiliza la compresión BPTC con componentes RGBA normalizados sin signo.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_BPTC_RGBF = 23

Formato de textura que utiliza la compresión BPTC con componentes RGB reales firmados.

Format FORMAT_BPTC_RGBFU = 24

Formato de textura que utiliza la compresión BPTC con componentes RGB reales sin firmar.

Format FORMAT_ETC = 25

Formato de Compresión de Textura Ericsson 1, también conocido como "ETC1", y es parte del estándar de gráficos OpenGL ES. Este formato no puede almacenar un canal alfa.

Format FORMAT_ETC2_R11 = 26

Formato de compresión de textura Ericsson 2 (R11_EAC variant), que proporciona un canal de datos sin firmar.

Format FORMAT_ETC2_R11S = 27

Formato de compresión de textura de Ericsson 2 (variante de SIGNED_R11_EAC), que proporciona un canal de datos firmado.

Format FORMAT_ETC2_RG11 = 28

Formato de compresión de textura de Ericsson 2 (RG11_EAC variant), que proporciona dos canales de datos sin firmar.

Format FORMAT_ETC2_RG11S = 29

Formato de compresión de textura de Ericsson 2 (variante de SIGNED_RG11_EAC), que proporciona dos canales de datos firmados.

Format FORMAT_ETC2_RGB8 = 30

Formato de compresión de textura de Ericsson 2 (RGB8 variant), que es una continuación del ETC1 y comprime los datos del RGB888.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_ETC2_RGBA8 = 31

Formato de compresión de textura de Ericsson 2 (RGBA8variant), que comprime los datos de RGBA8888 con soporte alfa completo.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_ETC2_RGB8A1 = 32

Formato de compresión de textura de Ericsson 2 (RGB8_PUNCHTHROUGH_ALPHA1 variant), que comprime los datos de RGBA para hacer el alfa totalmente transparente o totalmente opaco.

Nota: Al crear una ImageTexture, se realiza una conversión del espacio de color sRGB a lineal.

Format FORMAT_ETC2_RA_AS_RG = 33

Formato de compresión de textura de Ericsson 2 (variante RGBA8), que comprime los datos RA y los interpreta como dos canales (rojo y verde). Véase también FORMAT_ETC2_RGBA8.

Format FORMAT_DXT5_RA_AS_RG = 34

El formato de textura S3TC, también conocido como Block Compression 3 o BC3, que comprime los datos RA y los interpreta como dos canales (rojo y verde). Véase también FORMAT_DXT5.

Format FORMAT_ASTC_4x4 = 35

Compresión de textura adaptable y escalable. Esto implementa el modo 4×4 (alta calidad).

Format FORMAT_ASTC_4x4_HDR = 36

Mismo formato que FORMAT_ASTC_4x4, pero con la pista para que la GPU sepa que se utiliza para HDR.

Format FORMAT_ASTC_8x8 = 37

Compresión de textura adaptable y escalable. Esto implementa el modo 8×8 (baja calidad).

Format FORMAT_ASTC_8x8_HDR = 38

Mismo formato que FORMAT_ASTC_8x8, pero con la pista para que la GPU sepa que se utiliza para HDR.

Format FORMAT_MAX = 39

Representa el tamaño del enum Format.

enum Interpolation: 🔗

Interpolation INTERPOLATE_NEAREST = 0

Realiza la interpolación del vecino más cercano. Si se cambia el tamaño de la imagen, será pixelada.

Interpolation INTERPOLATE_BILINEAR = 1

Realiza una interpolación bilineal. Si se cambia el tamaño de la imagen, será borrosa. Este modo es más rápido que INTERPOLATE_CUBIC, pero da como resultado una menor calidad.

Interpolation INTERPOLATE_CUBIC = 2

Realiza una interpolación cúbica. Si se cambia el tamaño de la imagen, será borrosa. Este modo a menudo da mejores resultados en comparación con INTERPOLATE_BILINEAR, a costa de ser más lento.

Interpolation INTERPOLATE_TRILINEAR = 3

Performs bilinear separately on the two most-suited mipmap levels, then linearly interpolates between them.

It's slower than INTERPOLATE_BILINEAR, but produces higher-quality results with far fewer aliasing artifacts.

If the image does not have mipmaps, they will be generated and used internally, but no mipmaps will be generated on the resulting image.

Note: If you intend to scale multiple copies of the original image, it's better to call generate_mipmaps()] on it in advance, to avoid wasting processing power in generating them again and again.

On the other hand, if the image already has mipmaps, they will be used, and a new set will be generated for the resulting image.

Interpolation INTERPOLATE_LANCZOS = 4

Performs Lanczos interpolation. This is the slowest image resizing mode, but it typically gives the best results, especially when downscaling images.

enum AlphaMode: 🔗

AlphaMode ALPHA_NONE = 0

La imagen no tiene alfa.

AlphaMode ALPHA_BIT = 1

La imagen almacena el alfa en un solo bit.

AlphaMode ALPHA_BLEND = 2

La imagen usa el alfa.

enum CompressMode: 🔗

CompressMode COMPRESS_S3TC = 0

Use la compresión S3TC.

CompressMode COMPRESS_ETC = 1

Use la compresión ETC.

CompressMode COMPRESS_ETC2 = 2

Use la compresión ETC2.

CompressMode COMPRESS_BPTC = 3

Usa la compresión BPTC.

CompressMode COMPRESS_ASTC = 4

Usa la compresión ASTC.

CompressMode COMPRESS_MAX = 5

Representa el tamaño del enum CompressMode.

enum UsedChannels: 🔗

UsedChannels USED_CHANNELS_L = 0

La imagen solo usa un canal para la luminancia (escala de grises).

UsedChannels USED_CHANNELS_LA = 1

La imagen usa dos canales para la luminancia y el alfa, respectivamente.

UsedChannels USED_CHANNELS_R = 2

La imagen solo usa el canal rojo.

UsedChannels USED_CHANNELS_RG = 3

La imagen usa dos canales para rojo y verde.

UsedChannels USED_CHANNELS_RGB = 4

La imagen usa tres canales para rojo, verde y azul.

UsedChannels USED_CHANNELS_RGBA = 5

La imagen usa cuatro canales para rojo, verde, azul y alfa.

enum CompressSource: 🔗

CompressSource COMPRESS_SOURCE_GENERIC = 0

La textura de la fuente (antes de la compresión) es una textura regular. Por defecto para todas las texturas.

CompressSource COMPRESS_SOURCE_SRGB = 1

La textura de la fuente (antes de la compresión) está en el espacio sRGB.

CompressSource COMPRESS_SOURCE_NORMAL = 2

La textura de la fuente (antes de la compresión) es una textura normal (por ejemplo, puede ser comprimida en dos canales).

enum ASTCFormat: 🔗

ASTCFormat ASTC_FORMAT_4x4 = 0

Pista para indicar que se debe utilizar el formato de compresión ASTC 4×4 de alta calidad.

ASTCFormat ASTC_FORMAT_8x8 = 1

Pista para indicar que se debe utilizar el formato de compresión ASTC 8×8 de baja calidad.

Constantes

MAX_WIDTH = 16777216 🔗

El ancho máximo permitido para los recursos Image.

MAX_HEIGHT = 16777216 🔗

La altura máxima permitida para los recursos Image.

Descripciones de Propiedades

Dictionary data = { "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 } 🔗

Contiene todos los datos de color de la imagen en un formato dado. Véase las constantes de Format.

Descripciones de Métodos

void adjust_bcs(brightness: float, contrast: float, saturation: float) 🔗

Ajusta el brightness (brillo), contrast (contraste) y la saturation (saturación) de esta imagen por los valores dados. No funciona si la imagen está comprimida (véase is_compressed()).

void blend_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗

Mezcla el alfa src_rect de la imagen src a esta imagen en las coordenadas dst, recortada de acuerdo con los límites de ambas imágenes. Esta imagen y la imagen src deben tener el mismo formato. src_rect con tamaño no positivo se trata como vacío.

void blend_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i) 🔗

Alpha-blends src_rect from src image to this image using mask image at coordinates dst, clipped accordingly to both image bounds. Alpha channels are required for both src and mask. dst pixels and src pixels will blend if the corresponding mask pixel's alpha value is not 0. This image and src image must have the same format. src image and mask image must have the same size (width and height) but they can have different formats. src_rect with non-positive size is treated as empty.

void blit_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗

Copies src_rect from src image to this image at coordinates dst, clipped accordingly to both image bounds. This image and src image must have the same format. src_rect with non-positive size is treated as empty.

Note: The alpha channel data in src will overwrite the corresponding data in this image at the target position. To blend alpha channels, use blend_rect() instead.

void blit_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i) 🔗

Blits src_rect area from src image to this image at the coordinates given by dst, clipped accordingly to both image bounds. src pixel is copied onto dst if the corresponding mask pixel's alpha value is not 0. This image and src image must have the same format. src image and mask image must have the same size (width and height) but they can have different formats. src_rect with non-positive size is treated as empty.

void bump_map_to_normal_map(bump_scale: float = 1.0) 🔗

Converts a bump map to a normal map. A bump map provides a height offset per-pixel, while a normal map provides a normal direction per pixel.

void clear_mipmaps() 🔗

Elimina los mipmaps de la imagen.

Error compress(mode: CompressMode, source: CompressSource = 0, astc_format: ASTCFormat = 0) 🔗

Compresses the image to use less memory. Can not directly access pixel data while the image is compressed. Returns error if the chosen compression mode is not available.

The source parameter helps to pick the best compression method for DXT and ETC2 formats. It is ignored for ASTC compression.

For ASTC compression, the astc_format parameter must be supplied.

Error compress_from_channels(mode: CompressMode, channels: UsedChannels, astc_format: ASTCFormat = 0) 🔗

Comprime la imagen para usar menos memoria. No se puede acceder directamente a los datos de los píxeles mientras la imagen está comprimida. Devuelve un error si el modo de compresión elegido no está disponible.

Esta es una alternativa a compress() que permite al usuario proporcionar los canales utilizados para que el compresor elija los mejores formatos DXT y ETC2. Para otros formatos (no DXT o ETC2), este argumento se ignora.

Para la compresión ASTC, se debe proporcionar el parámetro astc_format.

Dictionary compute_image_metrics(compared_image: Image, use_luma: bool) 🔗

Calcula las métricas de la imagen en la imagen actual y la imagen comparada.

El diccionario contiene max, mean, mean_squared, root_mean_squared y peak_snr.

void convert(format: Format) 🔗

Convierte el formato de esta imagen al format dado.

void copy_from(src: Image) 🔗

Copia la imagen src a esta imagen.

Image create(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗

Obsoleto: Use create_empty().

Crea una imagen vacía con el tamaño y formato dados. Si use_mipmaps es true, genera mipmaps para esta imagen. Véase generate_mipmaps().

Image create_empty(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗

Crea una imagen vacía con el tamaño y formato dados. Si use_mipmaps es true, genera mipmaps para esta imagen. Véase generate_mipmaps().

Image create_from_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) static 🔗

Creates a new image of the given size and format. Fills the image with the given raw data. If use_mipmaps is true, loads the mipmaps for this image from data. See generate_mipmaps().

void crop(width: int, height: int) 🔗

Recorta la imagen al width y height dados. Si el tamaño especificado es mayor que el actual, el área extra se rellena con píxeles negros.

Error decompress() 🔗

Descomprime la imagen si está comprimida en VRAM en un formato compatible. Devuelve @GlobalScope.OK si el formato es compatible, de lo contrario @GlobalScope.ERR_UNAVAILABLE.

Nota: Los siguientes formatos se pueden descomprimir: DXT, RGTC, BPTC. Los formatos ETC1 y ETC2 no son compatibles.

AlphaMode detect_alpha() const 🔗

Devuelve ALPHA_BLEND si la imagen tiene datos para valores alfa. Devuelve ALPHA_BIT si todos los valores alfa están almacenados en un solo bit. Devuelve ALPHA_NONE si no se encuentran datos para valores alfa.

UsedChannels detect_used_channels(source: CompressSource = 0) const 🔗

Returns the color channels used by this image. If the image is compressed, the original source must be specified.

void fill(color: Color) 🔗

Rellena la imagen con color.

void fill_rect(rect: Rect2i, color: Color) 🔗

Rellena rect con color.

void fix_alpha_edges() 🔗

Mezcla píxeles con el nivel alfa bajo con píxeles cercanos.

void flip_x() 🔗

Voltea la imagen horizontalmente.

void flip_y() 🔗

Voltea la imagen verticalmente.

Error generate_mipmaps(renormalize: bool = false) 🔗

Genera mipmaps para la imagen. Los mipmaps son copias precalculadas de menor resolución de la imagen que se utilizan automáticamente si la imagen necesita ser reducida cuando se renderiza. Esto ayuda a mejorar la calidad de la imagen y el rendimiento al renderizar. Este método devuelve un error si la imagen está comprimida, en un formato personalizado o si el ancho/alto de la imagen es 0. Habilitar renormalize al generar mipmaps para texturas de mapas normales asegurará que todos los valores vectoriales resultantes estén normalizados.

Es posible verificar si la imagen tiene mipmaps llamando a has_mipmaps() o get_mipmap_count(). Llamar a generate_mipmaps() en una imagen que ya tiene mipmaps reemplazará los mipmaps existentes en la imagen.

PackedByteArray get_data() const 🔗

Devuelve una copia de los datos sin procesar de la imagen.

int get_data_size() const 🔗

Devuelve el tamaño (en bytes) de los datos sin procesar de la imagen.

Format get_format() const 🔗

Devuelve el formato de esta imagen.

int get_height() const 🔗

Devuelve la altura de la imagen.

int get_mipmap_count() const 🔗

Devuelve el número de niveles de mipmap o 0 si la imagen no tiene mipmaps. La imagen principal más grande no se cuenta como un nivel de mipmap en este método, por lo que, si quieres incluirla, puedes añadir 1 a este conteo.

int get_mipmap_offset(mipmap: int) const 🔗

Devuelve el desplazamiento donde el mipmap de la imagen con el índice mipmap se almacena en el diccionario data.

Color get_pixel(x: int, y: int) const 🔗

Devuelve el color del píxel en (x, y).

Esto es lo mismo que get_pixelv(), pero con dos argumentos enteros en lugar de un argumento Vector2i.

Color get_pixelv(point: Vector2i) const 🔗

Devuelve el color del píxel en point.

Es lo mismo que get_pixel(), pero con un argumento Vector2i en lugar de dos argumentos enteros.

Image get_region(region: Rect2i) const 🔗

Devuelve una nueva Image que es una copia del área de esta Image especificada con region.

Vector2i get_size() const 🔗

Devuelve el tamaño de la imagen (anchura y altura).

Rect2i get_used_rect() const 🔗

Devuelve un Rect2i que encierra la porción visible de la imagen, considerando cada píxel con un canal alfa no nulo como visible.

int get_width() const 🔗

Devuelve el ancho de la imagen.

bool has_mipmaps() const 🔗

Devuelve true si la imagen ha generado mipmaps.

bool is_compressed() const 🔗

Devuelve true si la imagen está comprimida.

bool is_empty() const 🔗

Devuelve true si la imagen no tiene datos.

bool is_invisible() const 🔗

Devuelve true si todos los píxeles de la imagen tienen un valor alfa de 0. Devuelve false si algún píxel tiene un valor alfa superior a 0.

void linear_to_srgb() 🔗

Convierte toda la imagen del espacio de color lineal al espacio de color sRGB. Solo funciona en imágenes con formatos FORMAT_RGB8 o FORMAT_RGBA8.

Error load(path: String) 🔗

Loads an image from file path. See Supported image formats for a list of supported image formats and limitations.

Warning: This method should only be used in the editor or in cases when you need to load external images at run-time, such as images located at the user:// directory, and may not work in exported projects.

See also ImageTexture description for usage examples.

Error load_bmp_from_buffer(buffer: PackedByteArray) 🔗

Loads an image from the binary contents of a BMP file.

Note: Godot's BMP module doesn't support 16-bit per pixel images. Only 1-bit, 4-bit, 8-bit, 24-bit, and 32-bit per pixel images are supported.

Note: This method is only available in engine builds with the BMP module enabled. By default, the BMP module is enabled, but it can be disabled at build-time using the module_bmp_enabled=no SCons option.

Error load_dds_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen desde el contenido binario de un archivo DDS.

Nota: Este método solo está disponible en las compilaciones del motor con el módulo DDS habilitado. Por defecto, el módulo DDS está habilitado, pero se puede deshabilitar en tiempo de compilación utilizando la opción SCons module_dds_enabled=no.

Image load_from_file(path: String) static 🔗

Creates a new Image and loads data from the specified file.

Error load_jpg_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen del contenido binario de un archivo JPEG.

Error load_ktx_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen desde el contenido binario de un archivo KTX. A diferencia de la mayoría de los formatos de imagen, KTX puede almacenar datos comprimidos en la VRAM e incrustar mipmaps.

Nota: La implementación de libktx de Godot solo admite imágenes 2D. No se admiten mapas de entorno (cubemaps), arrays de texturas ni des-padding.

Nota: Este método solo está disponible en compilaciones del motor con el módulo KTX habilitado. De forma predeterminada, el módulo KTX está habilitado, pero se puede deshabilitar en tiempo de compilación utilizando la opción SCons module_ktx_enabled=no.

Error load_png_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen del contenido binario de un archivo PNG.

Error load_svg_from_buffer(buffer: PackedByteArray, scale: float = 1.0) 🔗

Carga una imagen desde el contenido binario UTF-8 de un archivo SVG sin comprimir (.svg).

Nota: Ten cuidado al usar archivos SVG comprimidos (como .svgz), deben ser descomprimidos antes de cargarlos.

Nota: Este método solo está disponible en compilaciones del motor con el módulo SVG habilitado. De forma predeterminada, el módulo SVG está habilitado, pero se puede deshabilitar en tiempo de compilación utilizando la opción SCons module_svg_enabled=no.

Error load_svg_from_string(svg_str: String, scale: float = 1.0) 🔗

Carga una imagen desde el contenido de texto de un archivo SVG (.svg).

Nota: Este método solo está disponible en compilaciones del motor con el módulo SVG habilitado. De forma predeterminada, el módulo SVG está habilitado, pero se puede deshabilitar en tiempo de compilación utilizando la opción SCons module_svg_enabled=no.

Error load_tga_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen desde el contenido binario de un archivo TGA.

Nota: Este método solo está disponible en compilaciones del motor con el módulo TGA habilitado. De forma predeterminada, el módulo TGA está habilitado, pero se puede deshabilitar en tiempo de compilación utilizando la opción SCons module_tga_enabled=no.

Error load_webp_from_buffer(buffer: PackedByteArray) 🔗

Carga una imagen del contenido binario de un archivo WebP.

void normal_map_to_xy() 🔗

Convierte los datos de la imagen para representar coordenadas en un plano 3D. Esto se utiliza cuando la imagen representa un mapa de normales. Un mapa de normales puede agregar muchos detalles a una superficie 3D sin aumentar el conteo de polígonos.

void premultiply_alpha() 🔗

Multiplica los valores de color por los valores alfa. Los valores de color resultantes para un píxel son (color * alpha)/256. Véase también CanvasItemMaterial.blend_mode.

void resize(width: int, height: int, interpolation: Interpolation = 1) 🔗

Redimensiona la imagen al width y height dados. Los nuevos píxeles se calculan utilizando el modo de interpolation definido a través de las constantes de Interpolation.

void resize_to_po2(square: bool = false, interpolation: Interpolation = 1) 🔗

Redimensiona la imagen a la potencia de 2 más cercana para el ancho y la altura. Si square es true, establece el ancho y la altura al mismo valor. Los nuevos píxeles se calculan utilizando el modo de interpolation definido a través de las constantes de Interpolation.

Image rgbe_to_srgb() 🔗

Convierte una imagen estándar RGBE (Red Green Blue Exponent) en una imagen sRGB.

void rotate_90(direction: ClockDirection) 🔗

Rota la imagen en la direction especificada en 90 grados. El ancho y el alto de la imagen deben ser mayores que 1. Si el ancho y el alto no son iguales, la imagen se redimensionará.

void rotate_180() 🔗

Rota la imagen en 180 grados. El ancho y el alto de la imagen deben ser mayores que 1.

Error save_dds(path: String) const 🔗

Guarda la imagen como un archivo DDS (DirectDraw Surface) en path. DDS es un formato contenedor que puede almacenar texturas en varios formatos de compresión, como DXT1, DXT5 o BC7. Esta función devolverá @GlobalScope.ERR_UNAVAILABLE si Godot se compiló sin el módulo DDS.

Nota: El módulo DDS puede estar deshabilitado en ciertas compilaciones, lo que significa que save_dds() devolverá @GlobalScope.ERR_UNAVAILABLE cuando se le llame desde un proyecto exportado.

PackedByteArray save_dds_to_buffer() const 🔗

Guarda la imagen como un archivo DDS (DirectDraw Surface) en un array de bytes. DDS es un formato contenedor que puede almacenar texturas en varios formatos de compresión, como DXT1, DXT5 o BC7. Esta función devolverá un array de bytes vacío si Godot se compiló sin el módulo DDS.

Nota: El módulo DDS puede estar deshabilitado en ciertas compilaciones, lo que significa que save_dds_to_buffer() devolverá un array de bytes vacío cuando se le llame desde un proyecto exportado.

Error save_exr(path: String, grayscale: bool = false) const 🔗

Guarda la imagen como un archivo EXR en path. Si grayscale es true y la imagen tiene solo un canal, se guardará explícitamente como monocromo en lugar de como un canal rojo. Esta función devolverá @GlobalScope.ERR_UNAVAILABLE si Godot se compiló sin el módulo TinyEXR.

Nota: El módulo TinyEXR está deshabilitado en las compilaciones que no son del editor, lo que significa que save_exr() devolverá @GlobalScope.ERR_UNAVAILABLE cuando se le llame desde un proyecto exportado.

PackedByteArray save_exr_to_buffer(grayscale: bool = false) const 🔗

Guarda la imagen como un archivo EXR en un array de bytes. Si grayscale es true y la imagen tiene solo un canal, se guardará explícitamente como monocromo en lugar de como un canal rojo. Esta función devolverá un array de bytes vacío si Godot se compiló sin el módulo TinyEXR.

Nota: El módulo TinyEXR está deshabilitado en las compilaciones que no son del editor, lo que significa que save_exr_to_buffer() devolverá un array de bytes vacío cuando se le llame desde un proyecto exportado.

Error save_jpg(path: String, quality: float = 0.75) const 🔗

Guarda la imagen como un archivo JPEG en path con el quality especificado entre 0.01 y 1.0 (inclusive). Los valores más altos de quality dan como resultado una salida de mejor aspecto a costa de tamaños de archivo más grandes. Los valores recomendados de quality están entre 0.75 y 0.90. Incluso con calidad 1.00, la compresión JPEG sigue teniendo pérdida.

Nota: JPEG no guarda un canal alfa. Si la Image contiene un canal alfa, la imagen se guardará de todos modos, pero el archivo JPEG resultante no contendrá el canal alfa.

PackedByteArray save_jpg_to_buffer(quality: float = 0.75) const 🔗

Guarda la imagen como un archivo JPEG en un array de bytes con la quality especificada entre 0.01 y 1.0 (inclusive). Los valores más altos de quality dan como resultado una salida de mejor aspecto a costa de tamaños de array de bytes más grandes (y, por lo tanto, un mayor uso de memoria). Los valores recomendados de quality están entre 0.75 y 0.90. Incluso con calidad 1.00, la compresión JPEG sigue teniendo pérdida.

Nota: JPEG no guarda un canal alfa. Si la Image contiene un canal alfa, la imagen se guardará de todos modos, pero el array de bytes resultante no contendrá el canal alfa.

Error save_png(path: String) const 🔗

Guarda la imagen como un archivo PNG en el archivo en path.

PackedByteArray save_png_to_buffer() const 🔗

Guarda la imagen como un archivo PNG en un array de bytes.

Error save_webp(path: String, lossy: bool = false, quality: float = 0.75) const 🔗

Guarda la imagen como un archivo WebP (Web Picture) en el archivo en path. Por defecto, se guardará sin pérdida. Si lossy es true, la imagen se guardará con pérdida, utilizando el ajuste quality entre 0.0 y 1.0 (inclusive). WebP sin pérdida ofrece una compresión más eficiente que PNG.

Nota: El formato WebP está limitado a un tamaño de 16383×16383 píxeles, mientras que PNG puede guardar imágenes más grandes.

PackedByteArray save_webp_to_buffer(lossy: bool = false, quality: float = 0.75) const 🔗

Guarda la imagen como un archivo WebP (Web Picture) en un array de bytes. De forma predeterminada, se guardará sin pérdida. Si lossy es true, la imagen se guardará con pérdida, utilizando el ajuste quality entre 0.0 y 1.0 (inclusive). WebP sin pérdida ofrece una compresión más eficiente que PNG.

Nota: El formato WebP está limitado a un tamaño de 16383×16383 píxeles, mientras que PNG puede guardar imágenes más grandes.

void set_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) 🔗

Sobrescribe los datos de una Image existente. Equivalente no estático de create_from_data().

void set_pixel(x: int, y: int, color: Color) 🔗

Sets the Color of the pixel at (x, y) to color.

var img_width = 10
var img_height = 5
var img = Image.create(img_width, img_height, false, Image.FORMAT_RGBA8)

img.set_pixel(1, 2, Color.RED) # Sets the color at (1, 2) to red.

int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);

img.SetPixel(1, 2, Colors.Red); // Sets the color at (1, 2) to red.

This is the same as set_pixelv(), but with a two integer arguments instead of a Vector2i argument.

void set_pixelv(point: Vector2i, color: Color) 🔗

Sets the Color of the pixel at point to color.

var img_width = 10
var img_height = 5
var img = Image.create(img_width, img_height, false, Image.FORMAT_RGBA8)

img.set_pixelv(Vector2i(1, 2), Color.RED) # Sets the color at (1, 2) to red.

int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);

img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Sets the color at (1, 2) to red.

This is the same as set_pixel(), but with a Vector2i argument instead of two integer arguments.

void shrink_x2() 🔗

Reduce la imagen por un factor de 2 en cada eje (esto divide el número de píxeles por 4).

void srgb_to_linear() 🔗

Convierte los datos sin procesar del espacio de color sRGB a una escala lineal. Solo funciona en imágenes con formatos FORMAT_RGB8 o FORMAT_RGBA8.