Image
Eredita: Resource < RefCounted < Object
Tipo di dati d'immagine.
Descrizione
Tipo di dati d'immagine nativo. Contiene dati d'immagine che possono essere convertiti in un ImageTexture e fornisce metodi di elaborazione delle immagini di uso comune. La larghezza e l'altezza massime per un Image sono MAX_WIDTH e MAX_HEIGHT.
Un Image non può essere assegnato direttamente a una proprietà texture di un oggetto (come Sprite2D.texture) e deve essere prima convertito manualmente in un ImageTexture.
Nota: Le dimensioni massime di un'immagine sono 16384×16384 pixel a causa di limitazioni hardware grafiche. Immagini più grandi potrebbero non essere importate.
Tutorial
Proprietà
|
Metodi
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_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_to_buffer(grayscale: bool = false) 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 |
Enumerazioni
enum Format: 🔗
Format FORMAT_L8 = 0
Formato di texture con una singola profondità di 8 bit che rappresenta la luminanza.
Format FORMAT_LA8 = 1
Formato di texture OpenGL con due valori, luminanza e alfa, ciascuno memorizzato con 8 bit.
Format FORMAT_R8 = 2
Formato di texture OpenGL RED con un singolo componente di 8 bit.
Format FORMAT_RG8 = 3
Formato di texture OpenGL RG con due componenti, ciascuno di 8 bit.
Format FORMAT_RGB8 = 4
Formato di texture OpenGL RGB con tre componenti, ciascuno di 8 bit.
Nota: Creando una ImageTexture, viene effettuata una conversione da sRGB a spazio colore lineare.
Format FORMAT_RGBA8 = 5
Formato di texture OpenGL RGBA con quattro componenti, ciascuno di 8 bit.
Nota: Creando una ImageTexture, viene effettuata una conversione da sRGB a spazio colore lineare.
Format FORMAT_RGBA4444 = 6
Formato di texture OpenGL RGBA con quattro componenti, ciascuno di 8 bit.
Format FORMAT_RGB565 = 7
Formato di texture OpenGL RGB con tre componenti. Il rosso e il blu sono di 5 bit, e il verde è di 6 bit.
Format FORMAT_RF = 8
Formato di texture OpenGL GL_R32F in cui è presente un solo componente, un valore in virgola mobile di 32 bit.
Format FORMAT_RGF = 9
Formato di texture OpenGL GL_RG32F in cui sono presenti due componenti, ciascuno un valore in virgola mobile di 32 bit.
Format FORMAT_RGBF = 10
Formato di texture OpenGL GL_RGB32F in cui sono presenti tre componenti, ciascuno un valore in virgola mobile di 32 bit.
Format FORMAT_RGBAF = 11
Formato di texture OpenGL GL_RGBA32F in cui sono presenti quattro componenti, ciascuno un valore in virgola mobile di 32 bit.
Format FORMAT_RH = 12
Formato di texture OpenGL GL_R16F in cui è presente un solo componente, un valore in virgola mobile "a mezza precisione" di 16 bit.
Format FORMAT_RGH = 13
Formato di texture OpenGL GL_RG16F in cui sono presenti due componenti, ciascuno un valore in virgola mobile "a mezza precisione" di 16 bit.
Format FORMAT_RGBH = 14
Formato di texture OpenGL GL_RGB16F in cui sono presenti tre componenti, ciascuno un valore in virgola mobile "a mezza precisione" di 16 bit.
Format FORMAT_RGBAH = 15
Formato di texture OpenGL GL_RGBA16F in cui sono presenti quattro componenti, ciascuno un valore in virgola mobile "a mezza precisione" di 16 bit.
Format FORMAT_RGBE9995 = 16
Uno formato speciale di texture OpenGL in cui i tre componenti di colore hanno 9 bit di precisione e tutti e tre condividono un singolo esponente a 5 bit.
Format FORMAT_DXT1 = 17
Il formato di texture S3TC che utilizza Block Compression 1 ed è la più piccola variazione di S3TC, che fornisce solo 1 bit per l'alfa e i dati per il colore premoltiplicati con l'alfa.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_DXT3 = 18
Il formato di texture S3TC che utilizza Block Compression 2 e i dati per il colore sono interpretati come non premoltiplicati per l'alfa. Adatto per immagini con transizioni nette dell'alfa tra aree traslucide e opache.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_DXT5 = 19
Il formato di texture S3TC, noto anche come Block Compression 3 o BC3, contiene 64 bit di dati per il canale alfa, seguiti da 64 bit di dati per il colore codificati in DXT1. I dati per il colore non sono premoltiplicati per l'alfa, come in DXT3. DXT5 produce solitamente risultati superiori per i gradienti trasparenti rispetto a DXT3.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_RGTC_R = 20
Formato di texture che utilizza la Compressione di texture rosso-verde, normalizzando i dati del canale rosso attraverso lo stesso algoritmo di compressione che DXT5 utilizza per il canale alfa.
Format FORMAT_RGTC_RG = 21
Formato di texture che utilizza la Compressione di texture rosso-verde, normalizzando i dati del canale rosso e verde attraverso lo stesso algoritmo di compressione che DXT5 utilizza per il canale alfa.
Format FORMAT_BPTC_RGBA = 22
Formato di texture che utilizza la compressione BPTC con componenti RGBA normalizzati senza segno.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_BPTC_RGBF = 23
Formato di texture che utilizza la compressione BPTC con valori in virgola mobile con segno per i componenti RGB.
Format FORMAT_BPTC_RGBFU = 24
Formato di texture che utilizza la compressione BPTC con valori in virgola mobile senza segno per i componenti RGB.
Format FORMAT_ETC = 25
Formato di compressione di texture Ericsson 1, noto anche come "ETC1", e fa parte dello standard grafico OpenGL ES. Questo formato non può memorizzare un canale alfa.
Format FORMAT_ETC2_R11 = 26
Formato di compressione di texture Ericsson 2 (variante R11_EAC), che fornisce un solo canale di dati senza segno.
Format FORMAT_ETC2_R11S = 27
Formato di compressione di texture Ericsson 2 (variante SIGNED_R11_EAC), che fornisce un solo canale di dati con segno.
Format FORMAT_ETC2_RG11 = 28
Formato di compressione di texture Ericsson 2 (variante RG11_EAC), che fornisce un due canali di dati senza segno.
Format FORMAT_ETC2_RG11S = 29
Formato di compressione di texture Ericsson 2 (variante SIGNED_RG11_EAC), che fornisce un due canali di dati con segno.
Format FORMAT_ETC2_RGB8 = 30
Formato di compressione di texture Ericsson 2 (variante RGB8), che è un seguito di ETC1 e comprime i dati RGB888.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_ETC2_RGBA8 = 31
Formato di compressione di texture Ericsson 2 (RGBA8variante), che comprime i dati RGBA8888 con supporto completo per l'alfa.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_ETC2_RGB8A1 = 32
Formato di compressione texture Ericsson 2 (variante RGB8_PUNCHTHROUGH_ALPHA1), che comprime i dati RGBA per rendere l'alfa interamente trasparente o interamente opaco.
Nota: Creando un ImageTexture, sarà effettuata una conversione dello spazio colore sRGB in lineare.
Format FORMAT_ETC2_RA_AS_RG = 33
Formato di compressione di texture Ericsson 2 (variante RGBA8), che comprime i dati RA e li interpreta come due canali (rosso e verde). Vedi anche FORMAT_ETC2_RGBA8.
Format FORMAT_DXT5_RA_AS_RG = 34
Il formato di texture S3TC, noto anche come Block Compression 3 o BC3, che comprime i dati RA e li interpreta come due canali (rosso e verde). Vedi anche FORMAT_DXT5.
Format FORMAT_ASTC_4x4 = 35
Compressione adattiva scalabile di texture. Ciò implementa la modalità 4×4 (alta qualità).
Format FORMAT_ASTC_4x4_HDR = 36
Stesso formato di FORMAT_ASTC_4x4, ma fa sapere alla GPU che viene utilizzato per l'HDR.
Format FORMAT_ASTC_8x8 = 37
Adaptive Scalable Texture Compression. Ciò implementa la modalità 8×8 (bassa qualità).
Format FORMAT_ASTC_8x8_HDR = 38
Stesso formato di FORMAT_ASTC_8x8, ma fa sapere alla GPU che viene utilizzato per l'HDR.
Format FORMAT_MAX = 39
Rappresenta la dimensione dell'enumerazione Format.
enum Interpolation: 🔗
Interpolation INTERPOLATE_NEAREST = 0
Effettua l'interpolazione più vicino. Se l'immagine è ridimensionata, sarà pixelata.
Interpolation INTERPOLATE_BILINEAR = 1
Effettua l'interpolazione bilineare. Se l'immagine è ridimensionata, sarà sfocata. Questa modalità è più veloce di INTERPOLATE_CUBIC, ma produce risultati inferiori.
Interpolation INTERPOLATE_CUBIC = 2
Effettua l'interpolazione cubica. Se l'immagine è ridimensionata, sarà sfocata. Questa modalità spesso produce risultati migliori rispetto a INTERPOLATE_BILINEAR, ma è più lenta.
Interpolation INTERPOLATE_TRILINEAR = 3
Effettua separatamente l'interpolazione bilineare sui due livelli mipmap più adatti, quindi interpola linearmente tra di essi.
È più lento di INTERPOLATE_BILINEAR, ma produce risultati di qualità superiore con molti meno artefatti di aliasing.
Se l'immagine non ha mipmap, queste saranno generate e utilizzate internamente, ma nessuna mipmap sarà generata sull'immagine risultante.
Nota: Se si intende ridimensionare più copie dell'immagine originale, è meglio chiamare in anticipo generate_mipmaps()] su di essa, per evitare di sprecare tempo di elaborazione generandole più volte.
D'altra parte, se l'immagine ha già delle mipmap, queste saranno riutilizzate e sarà generato un nuovo set per l'immagine risultante.
Interpolation INTERPOLATE_LANCZOS = 4
Esegue l'interpolazione di Lanczos. Questa è la modalità di ridimensionamento delle immagini più lenta, ma in genere produce i risultati migliori, specialmente quando si rimpiccioliscono le immagini.
enum AlphaMode: 🔗
AlphaMode ALPHA_NONE = 0
L'immagine non ha alfa (opacità).
AlphaMode ALPHA_BIT = 1
L'immagine memorizza l'alfa in un solo bit.
AlphaMode ALPHA_BLEND = 2
L'immagine utilizza l'alfa (opacità).
enum CompressMode: 🔗
CompressMode COMPRESS_S3TC = 0
Utilizza la compressione S3TC.
CompressMode COMPRESS_ETC = 1
Utilizza la compressione ETC.
CompressMode COMPRESS_ETC2 = 2
Utilizza la compressione ETC2.
CompressMode COMPRESS_BPTC = 3
Utilizza la compressione BPTC.
CompressMode COMPRESS_ASTC = 4
Utilizza la compressione ASTC.
CompressMode COMPRESS_MAX = 5
Rappresenta la dimensione dell'enumerazione CompressMode.
enum UsedChannels: 🔗
UsedChannels USED_CHANNELS_L = 0
L'immagine utilizza un solo canale per la luminanza (scala di grigi).
UsedChannels USED_CHANNELS_LA = 1
L'immagine utilizza due canali rispettivamente per la luminanza e per l'alfa.
UsedChannels USED_CHANNELS_R = 2
L'immagine utilizza solo il canale rosso.
UsedChannels USED_CHANNELS_RG = 3
L'immagine utilizza due canali per il rosso e il verde.
UsedChannels USED_CHANNELS_RGB = 4
L'immagine utilizza tre canali per il rosso, il verde e il blu.
UsedChannels USED_CHANNELS_RGBA = 5
L'immagine utilizza quattro canali per il rosso, il verde, il blu e l'alfa.
enum CompressSource: 🔗
CompressSource COMPRESS_SOURCE_GENERIC = 0
La texture d'origine (prima della compressione) è una texture regolare. Predefinito per tutte le texture.
CompressSource COMPRESS_SOURCE_SRGB = 1
La texture d'origine (prima della compressione) è nello spazio sRGB.
CompressSource COMPRESS_SOURCE_NORMAL = 2
La texture d'origine (prima della compressione) è una texture normale (ad esempio può essere compressa in due canali).
enum ASTCFormat: 🔗
ASTCFormat ASTC_FORMAT_4x4 = 0
Suggerimento per indicare che è necessario utilizzare il formato di compressione ASTC 4×4 ad alta qualità.
ASTCFormat ASTC_FORMAT_8x8 = 1
Suggerimento per indicare che è necessario utilizzare il formato di compressione ASTC 8×8 a bassa qualità.
Costanti
MAX_WIDTH = 16777216 🔗
La larghezza massima consentita per le risorse Image.
MAX_HEIGHT = 16777216 🔗
L'altezza massima consentita per le risorse Image.
Descrizioni delle proprietà
Dictionary data = { "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 } 🔗
Contiene tutti i dati di colore dell'immagine in un formato specificato. Vedi le costanti di Format.
Descrizioni dei metodi
void adjust_bcs(brightness: float, contrast: float, saturation: float) 🔗
Regola i parametri di luminosità (brightness), contrasto (contrast) e saturazione (saturation) di questa immagine in base ai valori specificati. Non funziona se l'immagine è compressa (vedi is_compressed()).
void blend_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Fonde (con alpha) la regione src_rect dell'immagine src a questa immagine alle coordinate dst, ritagliata adeguatamente a entrambi i limiti dell'immagine. Questa immagine e l'immagine src devono avere lo stesso formato. src_rect con dimensioni non positive è trattata come vuota.
void blend_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Fonde con alfa la regione src_rect dall'immagine src a questa immagine usando la immagine maschera mask alle coordinate dst, ritagliate in base a entrambi i limiti delle immagini. I canali alfa sono necessari sia per src sia per mask. I pixel di dst e src si fonderanno se il valore alfa del pixel della maschera corrispondente non è 0. Questa immagine e l'immagine src devono avere lo stesso formato. L'immagine src e l'immagine maschera mask devono avere le stesse dimensioni (larghezza e altezza) ma possono avere formati diversi. src_rect con dimensioni non positive viene trattato come vuoto.
void blit_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Copia la regione src_rect dall'immagine src a questa immagine alle coordinate dst, ritagliata in base a entrambi i limiti delle immagini. Questa immagine e l'immagine src devono avere lo stesso formato. src_rect con dimensioni non positive viene trattato come vuoto.
Nota: I dati del canale alfa in src sovrascriveranno i dati corrispondenti in questa immagine nella posizione di destinazione. Per fondere i canali alfa, usa invece blend_rect().
void blit_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Blits la regione src_rect dall'immagine src a questa immagine alle coordinate fornite da dst, ritagliata in base a entrambi i limiti dell'immagine. Il pixel src viene copiato su dst se il valore alfa del pixel nella maschera mask corrispondente non è 0. Questa immagine e l'immagine src devono avere lo stesso formato. L'immagine src e l'immagine maschera mask devono avere le stesse dimensioni (larghezza e altezza) ma possono avere formati diversi. src_rect con dimensioni non positive viene trattato come vuoto.
void bump_map_to_normal_map(bump_scale: float = 1.0) 🔗
Converte una mappa di rilievo in una mappa normale. Una mappa di rilievo fornisce un offset di altezza per pixel, mentre una mappa normale fornisce una direzione normale per pixel.
void clear_mipmaps() 🔗
Rimuove i mipmap dell'immagine.
Error compress(mode: CompressMode, source: CompressSource = 0, astc_format: ASTCFormat = 0) 🔗
Comprime l'immagine per usare meno memoria. Non è possibile accedere direttamente ai dati dei pixel mentre l'immagine è compressa. Restituisce un errore se la modalità di compressione scelta non è disponibile.
Il parametro source aiuta a scegliere il metodo di compressione migliore per i formati DXT ed ETC2. È ignorato per la compressione ASTC.
Per la compressione ASTC, il parametro astc_format deve essere fornito.
Error compress_from_channels(mode: CompressMode, channels: UsedChannels, astc_format: ASTCFormat = 0) 🔗
Comprime l'immagine per usare meno memoria. Non è possibile accedere direttamente ai dati pixel mentre l'immagine è compressa. Restituisce un errore se la modalità di compressione scelta non è disponibile.
Questa è un'alternativa a compress() che consente all'utente di fornire i canali utilizzati affinché il compressore scelga i migliori formati DXT ed ETC2. Per altri formati (non DXT o ETC2), questo argomento è ignorato.
Per la compressione ASTC, il parametro astc_format deve essere fornito.
Dictionary compute_image_metrics(compared_image: Image, use_luma: bool) 🔗
Calcola le metriche dell'immagine sull'immagine attuale e sull'immagine confrontata.
Il dizionario contiene max (massimo), mean (media), mean_squared (media quadratica), root_mean_squared (scarto quadratico medio) e peak_snr (Peak signal-to-noise ratio).
void convert(format: Format) 🔗
Converte il formato di questa immagine al formato format.
Copia l'immagine src in questa immagine.
Image create(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗
Deprecato: Use create_empty().
Crea un'immagine vuota di dimensioni e formato specificati. Se use_mipmaps è true, genera i mipmap per questa immagine. Vedi generate_mipmaps().
Image create_empty(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗
Crea un'immagine vuota di dimensioni e formato specificati. Se use_mipmaps è true, genera i mipmap per questa immagine. Vedi generate_mipmaps().
Image create_from_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) static 🔗
Crea una nuova immagine di dimensioni e formato specificati. Riempie l'immagine con i dati grezzi specificati. Se use_mipmaps è true, genera i mipmap per questa immagine da data. Vedi generate_mipmaps().
void crop(width: int, height: int) 🔗
Ritaglia l'immagine in base ai parametri width e height. Se le dimensioni specificate sono maggiori delle dimensioni attuali, l'area aggiuntiva viene riempita con pixel neri.
Decomprime l'immagine se è compressa per VRAM in un formato supportato. Restituisce @GlobalScope.OK se il formato è supportato, altrimenti @GlobalScope.ERR_UNAVAILABLE.
Nota: I seguenti formati possono essere decompressi: DXT, RGTC, BPTC. I formati ETC1 ed ETC2 non sono supportati.
AlphaMode detect_alpha() const 🔗
Restituisce ALPHA_BLEND se l'immagine ha dati per i valori alfa. Restituisce ALPHA_BIT se tutti i valori alfa sono memorizzati in un singolo bit. Restituisce ALPHA_NONE se non sono trovati dati per i valori alfa.
UsedChannels detect_used_channels(source: CompressSource = 0) const 🔗
Restituisce i canali colore utilizzati da questa immagine. Se l'immagine è compressa, la sorgente originale (source) deve essere specificata.
Riempie l'immagine con il colore color.
void fill_rect(rect: Rect2i, color: Color) 🔗
Riempe il rettangolo rect con il colore color.
void fix_alpha_edges() 🔗
Fonde i pixel a bassa opacità con i pixel vicini.
void flip_x() 🔗
Capovolge l'immagine orizzontalmente.
void flip_y() 🔗
Capovolge l'immagine verticalmente.
Error generate_mipmaps(renormalize: bool = false) 🔗
Genera mipmap per l'immagine. Le mipmap sono copie precalcolate a bassa risoluzione dell'immagine che sono utilizzate automaticamente se l'immagine deve essere ridotta durante il rendering. Contribuiscono a migliorare la qualità dell'immagine e le prestazioni durante il rendering. Questo metodo restituisce un errore se l'immagine è compressa, in un formato personalizzato, o se la larghezza o l'altezza dell'immagine è 0. Abilitando renormalize durante la generazione delle mipmap per le texture di mappe normali, tutti i valori vettoriali risultanti saranno normalizzati.
È possibile verificare se l'immagine ha mipmap chiamando has_mipmaps() o get_mipmap_count(). Chiamando generate_mipmaps() su un'immagine che ha già mipmap, le mipmap esistenti nell'immagine saranno sostituite.
PackedByteArray get_data() const 🔗
Restituisce una copia dei dati grezzi dell'immagine.
Restituisce la dimensione (in byte) dei dati grezzi dell'immagine.
Restituisce il formato di questa immagine.
Restituisce l'altezza dell'immagine.
int get_mipmap_count() const 🔗
Restituisce il numero di livelli mipmap o 0 se l'immagine non ha mipmap. L'immagine di livello principale più grande non conta come livello mipmap da questo metodo, quindi se vuoi includerla puoi aggiungere 1 a questo conteggio.
int get_mipmap_offset(mipmap: int) const 🔗
Restituisce l'offset in cui il mipmap dell'immagine con indice mipmap è memorizzato nel dizionario data.
Color get_pixel(x: int, y: int) const 🔗
Restituisce il colore del pixel in (x, y).
È lo stesso di get_pixelv(), ma con due argomenti interi invece di un argomento Vector2i.
Color get_pixelv(point: Vector2i) const 🔗
Restituisce il colore del pixel nella posizione point.
È uguale a get_pixel(), ma con un argomento Vector2i invece di due argomenti interi.
Image get_region(region: Rect2i) const 🔗
Restituisce una nuova Image che è una copia dell'area di questa Image specificata con la regione region.
Restituisce le dimensioni dell'immagine (larghezza e altezza).
Rect2i get_used_rect() const 🔗
Restituisce un Rect2i che racchiude la porzione visibile dell'immagine, considerando ogni pixel con un canale alfa diverso da zero come visibile.
Restituisce la larghezza dell'immagine.
Restituisce true se l'immagine ha generato mipmap.
Restituisce true se l'immagine è compressa.
Restituisce true se l'immagine non contiene dati.
Restituisce true se tutti i pixel dell'immagine hanno un valore alfa pari a 0. Restituisce false se un pixel qualsiasi ha un valore alfa superiore a 0.
void linear_to_srgb() 🔗
Converte l'intera immagine dallo spazio colore lineare allo spazio colore sRGB. Funziona solo sulle immagini con il formato FORMAT_RGB8 o FORMAT_RGBA8.
Carica un'immagine dal file al percorso path. Consulta Formati immagine supportati per un elenco dei formati immagine supportati e delle limitazioni.
Attenzione: Questo metodo dovrebbe essere utilizzato solo nell'editor o nei casi in cui è necessario caricare immagini esterne in fase di esecuzione, come immagini situate nella cartella user://, e potrebbe non funzionare nei progetti esportati.
Consulta anche la descrizione di ImageTexture per esempi d'uso.
Error load_bmp_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file BMP.
Nota: Il modulo BMP di Godot non supporta immagini a 16 bit per pixel. Sono supportate solo immagini a 1 bit, 4 bit, 8 bit, 24 bit e 32 bit per pixel.
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo BMP abilitato. Per impostazione predefinita, il modulo BMP è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_bmp_enabled=no.
Error load_dds_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file DDS.
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo DDS abilitato. Per impostazione predefinita, il modulo DDS è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_dds_enabled=no.
Image load_from_file(path: String) static 🔗
Crea una nuova Image e carica i dati dal file specificato.
Error load_jpg_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file JPEG.
Error load_ktx_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file KTX. A differenza della maggior parte dei formati immagine, KTX può memorizzare dati compressi in VRAM e incorporare mipmap.
Nota: L'implementazione libktx di Godot supporta solo immagini 2D. Cubemap, array di texture e rimozione del padding non sono supportati.
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo KTX abilitato. Per impostazione predefinita, il modulo KTX è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_ktx_enabled=no.
Error load_png_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file PNG.
Error load_svg_from_buffer(buffer: PackedByteArray, scale: float = 1.0) 🔗
Carica un'immagine dal contenuto binario UTF-8 di un file SVG non compresso (.svg).
Nota: Fai attenzione quando usi file SVG compressi (come .svgz), devono essere decompressi prima di essere caricati.
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo SVG abilitato. Per impostazione predefinita, il modulo SVG è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_svg_enabled=no.
Error load_svg_from_string(svg_str: String, scale: float = 1.0) 🔗
Carica un'immagine dal contenuto come stringa di un file SVG (.svg).
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo SVG abilitato. Per impostazione predefinita, il modulo SVG è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_svg_enabled=no.
Error load_tga_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file TGA.
Nota: Questo metodo è disponibile solo nelle build del motore con il modulo TGA abilitato. Per impostazione predefinita, il modulo TGA è abilitato, ma può essere disabilitato in fase di compilazione attraverso l'opzione SCons module_tga_enabled=no.
Error load_webp_from_buffer(buffer: PackedByteArray) 🔗
Carica un'immagine dal contenuto binario di un file WebP.
void normal_map_to_xy() 🔗
Converte i dati dell'immagine per rappresentare coordinate su un piano 3D. È utilizzato quando l'immagine rappresenta una mappa normale. Una mappa normale può aggiungere molti dettagli a una superficie 3D senza aumentare il numero di poligoni.
void premultiply_alpha() 🔗
Moltiplica i valori di colore con i valori alfa. I valori di colore risultanti per un pixel sono (color * alpha)/256. Vedi anche CanvasItemMaterial.blend_mode.
void resize(width: int, height: int, interpolation: Interpolation = 1) 🔗
Ridimensiona l'immagine alla larghezza (width) e altezza (height) specificate. I nuovi pixel sono calcolati attraverso la modalità d'interpolazione interpolation definita tramite le costanti di Interpolation.
void resize_to_po2(square: bool = false, interpolation: Interpolation = 1) 🔗
Ridimensiona l'immagine alla potenza di 2 più vicina per larghezza e altezza. Se square è true imposta la larghezza e l'altezza in modo che siano uguali. I nuovi pixel vengono calcolati usando la modalità di interpolazione interpolation.
Converte un'immagine RGBE ("Red Green Blue Exponent") standard in un'immagine sRGB.
void rotate_90(direction: ClockDirection) 🔗
Ruota l'immagine nella direzione specificata da direction di 90 gradi. La larghezza e l'altezza dell'immagine devono essere maggiori di 1. Se la larghezza e l'altezza non sono uguali, l'immagine verrà ridimensionata.
void rotate_180() 🔗
Ruota l'immagine di 180 gradi. La larghezza e l'altezza dell'immagine devono essere maggiori di 1.
Error save_dds(path: String) const 🔗
Salva l'immagine come file DDS (DirectDraw Surface) nel percorso path. DDS è un formato contenitore che può memorizzare texture in vari formati di compressione, come DXT1, DXT5 o BC7. Questa funzione restituirà @GlobalScope.ERR_UNAVAILABLE se Godot è stato compilato senza il modulo DDS.
Nota: Il modulo DDS potrebbe essere disabilitato in certe build, il che significa che save_dds() restituirà @GlobalScope.ERR_UNAVAILABLE quando viene chiamato da un progetto esportato.
PackedByteArray save_dds_to_buffer() const 🔗
Salva l'immagine come file DDS (DirectDraw Surface) in un array di byte. DDS è un formato contenitore che può memorizzare texture in vari formati di compressione, come DXT1, DXT5 o BC7. Questa funzione restituirà @GlobalScope.ERR_UNAVAILABLE se Godot è stato compilato senza il modulo DDS.
Nota: Il modulo DDS potrebbe essere disabilitato in certe build, il che significa che save_dds_to_buffer() restituirà @GlobalScope.ERR_UNAVAILABLE quando viene chiamato da un progetto esportato.
Error save_exr(path: String, grayscale: bool = false) const 🔗
Salva l'immagine come file EXR nel percorso path. Se grayscale è true e l'immagine ha un solo canale, sarà salvata esplicitamente come monocromatica invece di utilizzare il canale rosso. Questa funzione restituirà @GlobalScope.ERR_UNAVAILABLE se Godot è stato compilato senza il modulo TinyEXR.
Nota: Il modulo TinyEXR è disabilitato nelle build non editor, il che significa che save_exr() restituirà @GlobalScope.ERR_UNAVAILABLE quando viene chiamato da un progetto esportato.
PackedByteArray save_exr_to_buffer(grayscale: bool = false) const 🔗
Salva l'immagine come file EXR in un array di byte. Se grayscale è true e l'immagine ha un solo canale, sarà salvata esplicitamente come monocromatica invece di utilizzare il canale rosso. Questa funzione restituirà un array di byte vuoto se Godot è stato compilato senza il modulo TinyEXR.
Nota: Il modulo TinyEXR è disabilitato nelle build non editor, il che significa che save_exr_to_buffer() restituirà un array di byte vuoto quando viene chiamato da un progetto esportato.
Error save_jpg(path: String, quality: float = 0.75) const 🔗
Salva l'immagine come file JPEG nel percorso path con la qualità quality specificata tra 0.01 e 1.0 (inclusi). Valori di quality più alti producono un aspetto migliore a costo di file più grandi. I valori quality consigliati sono compresi tra 0.75 e 0.90. Anche con una qualità di 1.00, la compressione JPEG rimane lossy.
Nota: JPEG non salva un canale alfa. Se l'Image contiene un canale alfa, l'immagine sarà comunque salvata, ma il file JPEG risultante non conterrà il canale alfa.
PackedByteArray save_jpg_to_buffer(quality: float = 0.75) const 🔗
Salva l'immagine come file JPEG in un array di byte con la qualità quality specificata tra 0.01 e 1.0 (inclusi). Valori di quality più alti producono un aspetto migliore a costo di array di byte più grandi (e quindi più memoria). I valori quality consigliati sono compresi tra 0.75 e 0.90. Anche con una qualità di 1.00, la compressione JPEG rimane lossy.
Nota: JPEG non salva un canale alfa. Se l'Image contiene un canale alfa, l'immagine sarà comunque salvata, ma l'array di byte risultante non conterrà il canale alfa.
Error save_png(path: String) const 🔗
Salva l'immagine come file PNG nel file nel percorso path.
PackedByteArray save_png_to_buffer() const 🔗
Salva l'immagine come file PNG in un array di byte.
Error save_webp(path: String, lossy: bool = false, quality: float = 0.75) const 🔗
Salva l'immagine come file WebP (Web Picture) nel percorso path. Per impostazione predefinita, salva senza perdita di dati. Se lossy è true, l'immagine sarà salvata con perdita di dati, utilizzando la qualità quality tra 0.0 e 1.0 (inclusi). WebP senza perdita offre una compressione più efficiente di PNG.
Nota: Il formato WebP è limitato a una dimensione di 16383×16383 pixel, mentre PNG può salvare immagini più grandi.
PackedByteArray save_webp_to_buffer(lossy: bool = false, quality: float = 0.75) const 🔗
Salva l'immagine come file WebP (Web Picture) in un array di byte. Per impostazione predefinita, salva senza perdita di dati. Se lossy è true, l'immagine sarà salvata con perdita di dati, utilizzando la qualità quality tra 0.0 e 1.0 (inclusi). WebP senza perdita offre una compressione più efficiente di PNG.
Nota: Il formato WebP è limitato a una dimensione di 16383×16383 pixel, mentre PNG può salvare immagini più grandi.
void set_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) 🔗
Sovrascrive i dati di un'Image esistente. Equivalente non statico di create_from_data().
void set_pixel(x: int, y: int, color: Color) 🔗
Imposta il Color del pixel nelle coordinate (x, y) su 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, Colore.ROSSO) # Imposta il colore in (1, 2) su rosso.
int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
img.SetPixel(1, 2, Colori.Rosso); // Imposta il colore in (1, 2) su rosso.
Questo è lo stesso di set_pixelv(), ma con due argomenti interi invece di un argomento Vector2i.
void set_pixelv(point: Vector2i, color: Color) 🔗
Imposta il Color del pixel nelle coordinate point su 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) # Imposta il colore in (1, 2) su rosso.
int imgWidth = 10;
int imgHeight = 5;
var img = Image.Create(imgWidth, imgHeight, false, Image.Format.Rgba8);
img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Imposta il colore in (1, 2) su rosso.
Questo è lo stesso di set_pixel(), ma con un argomento Vector2i invece di due argomenti interi.
void shrink_x2() 🔗
Rimpicciolisce l'immagine di un fattore 2 su ciascun asse (ciò divide il numero di pixel per 4).
void srgb_to_linear() 🔗
Converte i dati grezzi dallo spazio colore sRGB a quello lineare. Funziona solo sulle immagini con i formati FORMAT_RGB8 o FORMAT_RGBA8.