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...
Image
Hereda: Resource < RefCounted < Object
Tipo de datos de imagen.
Descripción
Tipo de dato de imagen nativo. Contiene datos de imagen que se pueden convertir en un ImageTexture y proporciona métodos de procesamiento de imágenes de uso común. El ancho y 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 a un ImageTexture.
Nota: Los métodos que modifican los datos de la imagen no se pueden usar en imágenes comprimidas en VRAM. Usa decompress() para convertir la imagen a un formato sin comprimir primero.
Nota: El tamaño máximo de imagen es de 16384×16384 píxeles debido a las limitaciones del hardware de gráficos. Las imágenes más grandes pueden no importarse.
Tutoriales
Propiedades
|
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 |
|
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 |
|
compress(mode: CompressMode, source: CompressSource = 0, astc_format: ASTCFormat = 0) |
|
compress_from_channels(mode: CompressMode, channels: UsedChannels, astc_format: ASTCFormat = 0) |
|
compute_image_metrics(compared_image: Image, use_luma: bool) |
|
void |
|
void |
|
create(width: int, height: int, use_mipmaps: bool, format: Format) static |
|
create_empty(width: int, height: int, use_mipmaps: bool, format: Format) static |
|
create_from_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) static |
|
void |
|
detect_alpha() const |
|
detect_used_channels(source: CompressSource = 0) const |
|
void |
|
void |
|
void |
|
void |
flip_x() |
void |
flip_y() |
generate_mipmaps(renormalize: bool = false) |
|
get_data() const |
|
get_data_size() const |
|
get_format() const |
|
get_height() const |
|
get_mipmap_count() const |
|
get_mipmap_offset(mipmap: int) const |
|
get_pixelv(point: Vector2i) const |
|
get_region(region: Rect2i) const |
|
get_size() const |
|
get_used_rect() const |
|
get_width() const |
|
has_mipmaps() const |
|
is_compressed() const |
|
is_empty() const |
|
is_invisible() const |
|
void |
|
load_bmp_from_buffer(buffer: PackedByteArray) |
|
load_dds_from_buffer(buffer: PackedByteArray) |
|
load_exr_from_buffer(buffer: PackedByteArray) |
|
load_from_file(path: String) static |
|
load_jpg_from_buffer(buffer: PackedByteArray) |
|
load_ktx_from_buffer(buffer: PackedByteArray) |
|
load_png_from_buffer(buffer: PackedByteArray) |
|
load_svg_from_buffer(buffer: PackedByteArray, scale: float = 1.0) |
|
load_svg_from_string(svg_str: String, scale: float = 1.0) |
|
load_tga_from_buffer(buffer: PackedByteArray) |
|
load_webp_from_buffer(buffer: PackedByteArray) |
|
void |
|
void |
|
void |
resize(width: int, height: int, interpolation: Interpolation = 1) |
void |
resize_to_po2(square: bool = false, interpolation: Interpolation = 1) |
void |
rotate_90(direction: ClockDirection) |
void |
|
save_dds_to_buffer() const |
|
save_exr(path: String, grayscale: bool = false, color_image: bool = false, max_linear_value: float = -1.0) const |
|
save_exr_to_buffer(grayscale: bool = false, color_image: bool = false, max_linear_value: float = -1.0) const |
|
save_jpg_to_buffer(quality: float = 0.75) const |
|
save_png_to_buffer() const |
|
save_webp(path: String, lossy: bool = false, quality: float = 0.75) const |
|
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 |
|
void |
set_pixelv(point: Vector2i, color: Color) |
void |
|
void |
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 RGBA con cuatro 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, solo proporciona 1 bit de alfa y datos de color premultiplicados con alfa.
Nota: Al crear una ImageTexture, se realiza una conversión de codificación sRGB no lineal 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 no premultiplicados por el alfa. Bien adaptado para imágenes con transiciones alfa nítidas entre áreas translúcidas y opacas.
Nota: Al crear una ImageTexture, se realiza una conversión de codificación sRGB no lineal 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 están premultiplicados por el alfa, igual que DXT3. DXT5 generalmente produce resultados superiores para gradientes transparentes en comparación con DXT3.
Nota: Al crear una ImageTexture, se realiza una conversión de codificación sRGB no lineal 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
Ericsson Texture Compression format 2 (RGB8 variant), which is a follow-up of ETC1 and compresses RGB888 data.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_ETC2_RGBA8 = 31
Ericsson Texture Compression format 2 (RGBA8variant), which compresses RGBA8888 data with full alpha support.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_ETC2_RGB8A1 = 32
Ericsson Texture Compression format 2 (RGB8_PUNCHTHROUGH_ALPHA1 variant), which compresses RGBA data to make alpha either fully transparent or fully opaque.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
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_R16 = 39
Formato de textura OpenGL GL_R16 donde hay un componente, un valor entero normalizado sin signo de 16 bits. Dado que el valor está normalizado, cada componente se limita entre 0.0 y 1.0 (inclusivo).
Nota: Debido al soporte limitado de hardware, se recomienda principalmente su uso en dispositivos de escritorio o consola. Puede que no sea compatible en dispositivos móviles o web, y en consecuencia se convertirá a FORMAT_RF.
Format FORMAT_RG16 = 40
Formato de textura OpenGL GL_RG16 donde hay dos componentes, cada uno un valor entero normalizado sin signo de 16 bits. Dado que el valor está normalizado, cada componente se limita entre 0.0 y 1.0 (inclusivo).
Nota: Debido al soporte limitado de hardware, se recomienda principalmente su uso en dispositivos de escritorio o consola. Puede que no sea compatible en dispositivos móviles o web, y en consecuencia se convertirá a FORMAT_RGF.
Format FORMAT_RGB16 = 41
Formato de textura OpenGL GL_RGB16 donde hay tres componentes, cada uno un valor entero normalizado sin signo de 16 bits. Dado que el valor está normalizado, cada componente se limita entre 0.0 y 1.0 (inclusivo).
Nota: Debido al soporte limitado de hardware, se recomienda principalmente su uso en dispositivos de escritorio o consola. Puede que no sea compatible en dispositivos móviles o web, y en consecuencia se convertirá a FORMAT_RGBF.
Format FORMAT_RGBA16 = 42
Formato de textura OpenGL GL_RGBA16 donde hay cuatro componentes, cada uno un valor entero normalizado sin signo de 16 bits. Dado que el valor está normalizado, cada componente se limita entre 0.0 y 1.0 (inclusivo).
Nota: Debido al soporte de hardware limitado, se recomienda principalmente su uso en dispositivos de escritorio o consola. Puede no ser compatible en dispositivos móviles o web, y consecuentemente se convertirá a FORMAT_RGBAF.
Format FORMAT_R16I = 43
Formato de textura OpenGL GL_R16UI donde hay un componente, un valor entero sin signo de 16 bits. Cada componente se limita entre 0 y 65535 (inclusivo).
Nota: Cuando se usa en un shader, la textura requiere el uso de samplers usampler. Además, solo soporta filtrado por vecino más cercano bajo el renderizador Compatibility.
Nota: Al muestrear usando get_pixel(), los Colors devueltos deben dividirse por 65535 para obtener el valor de color correcto.
Format FORMAT_RG16I = 44
Formato de textura OpenGL GL_RG16UI donde hay dos componentes, cada uno un valor entero sin signo de 16 bits. Cada componente se limita entre 0 y 65535 (inclusivo).
Nota: Cuando se usa en un shader, la textura requiere el uso de samplers usampler. Además, solo soporta filtrado por vecino más cercano bajo el renderizador Compatibility.
Nota: Al muestrear usando get_pixel(), los Colors devueltos deben dividirse por 65535 para obtener el valor de color correcto.
Format FORMAT_RGB16I = 45
Formato de textura OpenGL GL_RGB16UI donde hay tres componentes, cada uno un valor entero sin signo de 16 bits. Cada componente está limitado entre 0 y 65535 (inclusivo).
Nota: Cuando se usa en un shader, la textura requiere el uso de samplers usampler. Además, solo soporta filtrado de vecino más cercano bajo el renderizador Compatibility.
Nota: Al muestrear usando get_pixel(), los Colors devueltos deben ser divididos por 65535 para obtener el valor de color correcto.
Format FORMAT_RGBA16I = 46
Formato de textura OpenGL GL_RGBA16UI donde hay cuatro componentes, cada uno un valor entero sin signo de 16 bits. Cada componente está limitado entre 0 y 65535 (inclusivo).
Nota: Cuando se usa en un shader, la textura requiere el uso de samplers usampler. Además, solo soporta filtrado de vecino más cercano bajo el renderizador Compatibility.
Nota: Al muestrear usando get_pixel(), los Colors devueltos deben ser divididos por 65535 para obtener el valor de color correcto.
Format FORMAT_MAX = 47
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
Realiza la interpolación de Lanczos. Es el modo de redimensionamiento de imágenes más lento, pero suele dar los mejores resultados, especialmente cuando se reducen las imágenes.
enum AlphaMode: 🔗
AlphaMode ALPHA_NONE = 0
La imagen es completamente opaca. No almacena datos alfa.
AlphaMode ALPHA_BIT = 1
La imagen almacena píxeles completamente opacos o completamente transparentes. También conocido como alfa de perforación.
AlphaMode ALPHA_BLEND = 2
La imagen almacena datos alfa con valores que varían entre 0.0 y 1.0.
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 origen (antes de la compresión) utiliza codificación sRGB no lineal.
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) 🔗
Mezcla alfa src_rect de la imagen src a esta imagen usando la imagen mask en las coordenadas dst, recortada de acuerdo con los límites de ambas imágenes. Se requieren canales alfa tanto para src como para mask. Los píxeles de dst y los píxeles de src se mezclarán si el valor alfa del píxel de la máscara correspondiente no es 0. Esta imagen y la imagen src deben tener el mismo formato. La imagen src y la imagen mask deben tener el mismo tamaño (ancho y alto), pero pueden tener formatos diferentes. src_rect con tamaño no positivo se trata como vacío.
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 with a VRAM-compressed format 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.
The astc_format parameter is only taken into account when using ASTC compression; it is ignored for all other formats.
Note: compress() is only supported in editor builds. When run in an exported project, this method always returns @GlobalScope.ERR_UNAVAILABLE.
Error compress_from_channels(mode: CompressMode, channels: UsedChannels, astc_format: ASTCFormat = 0) 🔗
Compresses the image with a VRAM-compressed format 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.
This is an alternative to compress() that lets the user supply the channels used in order for the compressor to pick the best DXT and ETC2 formats. For other formats (non DXT or ETC2), this argument is ignored.
The astc_format parameter is only taken into account when using ASTC compression; it is ignored for all other formats.
Note: compress_from_channels() is only supported in editor builds. When run in an exported project, this method always returns @GlobalScope.ERR_UNAVAILABLE.
Dictionary compute_image_metrics(compared_image: Image, use_luma: bool) 🔗
Calcula las métricas de la imagen actual y la imagen comparada. Esto se puede usar para calcular la similitud entre dos imágenes.
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.
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 🔗
Crea una nueva imagen con el tamaño y formato dados. Llena la imagen con los datos en bruto dados. Si use_mipmaps es true, carga los mipmaps de esta imagen desde data. Véase 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.
Descomprime la imagen si está comprimida en VRAM en un formato compatible. Esto aumenta la utilización de memoria, pero permite modificar la imagen. Devuelve @GlobalScope.OK si el formato es compatible, de lo contrario @GlobalScope.ERR_UNAVAILABLE. Todos los formatos comprimidos en VRAM compatibles con Godot se pueden descomprimir con este método, excepto FORMAT_ETC2_R11S, FORMAT_ETC2_RG11S y FORMAT_ETC2_RGB8A1.
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 🔗
Devuelve los canales de color utilizados por esta imagen. Si la imagen está comprimida, se debe especificar el source original.
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.
Devuelve el tamaño (en bytes) de los datos sin procesar de la imagen.
Devuelve el formato de esta imagen.
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.
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.
Devuelve el ancho de la imagen.
Devuelve true si la imagen ha generado mipmaps.
Devuelve true si la imagen está comprimida.
Devuelve true si la imagen no tiene datos.
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 de codificación lineal a codificación sRGB no lineal utilizando una tabla de búsqueda. Solo funciona en imágenes con formatos FORMAT_RGB8 o FORMAT_RGBA8.
Carga una imagen del archivo path. Véase Formatos de imagen soportados para una lista de formatos de imagen soportados y sus limitaciones.
Advertencia: Este método solo debe utilizarse en el editor o en casos en los que necesites cargar imágenes externas en tiempo de ejecución, como imágenes ubicadas en el directorio user://, y puede que no funcione en proyectos exportados.
Véase también la descripción de ImageTexture para ejemplos de uso.
Error load_bmp_from_buffer(buffer: PackedByteArray) 🔗
Carga una imagen a partir del contenido binario de un archivo BMP.
Nota: El módulo BMP de Godot no soporta imágenes de 16 bits por píxel. Solo se soportan imágenes de 1, 4, 8, 24 y 32 bits por píxel.
Nota: Este método solo está disponible en compilaciones del motor con el módulo BMP activado. Por defecto, el módulo BMP está activado, pero se puede desactivar en tiempo de compilación utilizando la opción SCons module_bmp_enabled=no.
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.
Error load_exr_from_buffer(buffer: PackedByteArray) 🔗
Carga una imagen a partir del contenido binario de un archivo OpenEXR.
Image load_from_file(path: String) static 🔗
Crea una nueva Image y carga datos del archivo especificado.
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) 🔗
Resizes the image to the given width and height. New pixels are calculated using the interpolation mode defined via Interpolation constants.
Note: If the image's format is FORMAT_RGBA4444, FORMAT_RGB565, or FORMAT_RGBE9995, it will be temporarily converted to either FORMAT_RGBA8 or FORMAT_RGBAH. This can affect the quality of the resized image.
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.
Convierte una imagen RGBE (Red Green Blue Exponent) lineal estándar en una imagen que utiliza codificación sRGB no lineal.
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, color_image: bool = false, max_linear_value: float = -1.0) const 🔗
Saves the image as an EXR file to path. If grayscale is true and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. Set color_image to true when saving a color image, such as a screenshot. Negative values will be included when color_image is false, which may be useful for saving raw floating point data such as a lightmap that includes negative light information. Color component values in the resulting EXR file will not exceed max_linear_value if max_linear_value is not negative. This function will return @GlobalScope.ERR_UNAVAILABLE if Godot was compiled without the TinyEXR module.
When saving screenshots of a project that uses HDR output, use Window.get_output_max_linear_value() for max_linear_value.
PackedByteArray save_exr_to_buffer(grayscale: bool = false, color_image: bool = false, max_linear_value: float = -1.0) const 🔗
Saves the image as an EXR file to a byte array. If grayscale is true and the image has only one channel, it will be saved explicitly as monochrome rather than one red channel. Set color_image to true when saving a color image, such as a screenshot. Negative values will be included when color_image is false, which may be useful for saving raw floating point data such as a lightmap that includes negative light information. Color component values in the resulting EXR file will not exceed max_linear_value if max_linear_value is not negative. This function will return an empty byte array if Godot was compiled without the TinyEXR module.
When saving screenshots of a project that uses HDR output, use Window.get_output_max_linear_value() for max_linear_value.
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) 🔗
Establece el Color del píxel en (x, y) a 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) # Establece el color en (1, 2) a rojo.
int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
img.SetPixel(1, 2, Colors.Red); // Establece el color en (1, 2) a rojo.
Esto es lo mismo que set_pixelv(), pero con dos argumentos enteros en lugar de un argumento Vector2i.
Nota: Dependiendo del formato de la imagen, el color establecido aquí puede ser limitado o perder precisión. No asumas que el color devuelto por get_pixel() sea idéntico al establecido aquí; cualquier comparación probablemente necesitará usar una aproximación como Color.is_equal_approx().
Nota: En formatos de imagen en escala de grises, solo se utiliza el canal rojo de color (y el alfa si es relevante). Los canales verde y azul son ignorados.
void set_pixelv(point: Vector2i, color: Color) 🔗
Establece el Color del píxel en point a 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) # Establece el color en (1, 2) a rojo.
int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Establece el color en (1, 2) a rojo.
Esto es lo mismo que set_pixel(), pero con un argumento Vector2i en lugar de dos argumentos enteros.
Nota: Dependiendo del formato de la imagen, el color establecido aquí puede ser limitado o perder precisión. No asumas que el color devuelto por get_pixelv() sea idéntico al establecido aquí; cualquier comparación probablemente necesitará usar una aproximación como Color.is_equal_approx().
Nota: En formatos de imagen en escala de grises, solo se utiliza el canal rojo de color (y el alfa si es relevante). Los canales verde y azul son ignorados.
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 de la codificación sRGB no lineal a la codificación lineal usando una tabla de búsqueda. Solo funciona en imágenes con formatos FORMAT_RGB8 o FORMAT_RGBA8.
Nota: Los formatos de 8 bits requeridos por este método no son adecuados para almacenar valores codificados linealmente; se perderá una cantidad significativa de información de color en los valores más oscuros. Para mantener la calidad de la imagen, este método no debe usarse.