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
Hérite de : Resource < RefCounted < Object
Type de données d’image.
Description
Native image datatype. Contains image data which can be converted to an ImageTexture and provides commonly used image processing methods. The maximum width and height for an Image are MAX_WIDTH and MAX_HEIGHT.
An Image cannot be assigned to a texture property of an object directly (such as Sprite2D.texture), and has to be converted manually to an ImageTexture first.
Note: Methods that modify the image data cannot be used on VRAM-compressed images. Use decompress() to convert the image to an uncompressed format first.
Note: The maximum image size is 16384×16384 pixels due to graphics hardware limitations. Larger images may fail to import.
Tutoriels
Propriétés
|
Méthodes
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 |
Énumérations
enum Format: 🔗
Format FORMAT_L8 = 0
Un format de texture 8-bit représentant la luminance (niveaux de gris).
Format FORMAT_LA8 = 1
Format de texture OpenGL avec deux composantes, la luminance et l'opacité, chacune sur 8 bits.
Format FORMAT_R8 = 2
Format de texture OpenGL RED avec une unique composante sur 8 bits.
Format FORMAT_RG8 = 3
Format de texture OpenGL RG avec deux composantes, chacune sur 8 bits.
Format FORMAT_RGB8 = 4
OpenGL texture format RGB with three components, each with a bitdepth of 8.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_RGBA8 = 5
OpenGL texture format RGBA with four components, each with a bitdepth of 8.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_RGBA4444 = 6
Format de texture OpenGL RGBA où il y a quatre composantes, chacune sur 4 bits.
Format FORMAT_RGB565 = 7
Format de texture OpenGL RGB avec trois composantes. Rouge et bleu sont sur 5 bits, et vert sur 6.
Format FORMAT_RF = 8
Format de texture OpenGL GL_R32F où il n'y a qu'un seul composante, un flottant de 32 bits.
Format FORMAT_RGF = 9
Format de texture OpenGL GL_RG32F où il y a deux composantes, chacune un flottant de 32 bits.
Format FORMAT_RGBF = 10
Format de texture OpenGL GL_RGB32F où il y a trois composantes, chacune un flottant de 32 bits.
Format FORMAT_RGBAF = 11
Format de texture OpenGL GL_RGBA32F où il y a quatre composantes, chacune un flottant de 32 bits.
Format FORMAT_RH = 12
Format de texture OpenGL GL_R16F où il n'y a qu'une seule composante, un flottant en demi-précision sur 16 bits.
Format FORMAT_RGH = 13
Format de texture OpenGL GL_RG16F où il y a deux composantes, chacune un flottant en demi-précision sur 16 bits.
Format FORMAT_RGBH = 14
Format de texture OpenGL GL_RGB16F où il y a 3 composantes, chacune un flottant en demi-précision sur 16 bits.
Format FORMAT_RGBAH = 15
Format de texture OpenGL GL_RGB16F où il y a 4 composantes, chacune un flottant en demi-précision sur 16 bits.
Format FORMAT_RGBE9995 = 16
Un format de texture OpenGL spécial où les trois composantes de couleur ont 9 bits de précision et tous les trois partagent un seul exposant sur 5 bits.
Format FORMAT_DXT1 = 17
The S3TC texture format that uses Block Compression 1, and is the smallest variation of S3TC, only providing 1 bit of alpha and color data being premultiplied with alpha.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_DXT3 = 18
The S3TC texture format that uses Block Compression 2, and color data is interpreted as not having been premultiplied by alpha. Well suited for images with sharp alpha transitions between translucent and opaque areas.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_DXT5 = 19
The S3TC texture format also known as Block Compression 3 or BC3 that contains 64 bits of alpha channel data followed by 64 bits of DXT1-encoded color data. Color data is not premultiplied by alpha, same as DXT3. DXT5 generally produces superior results for transparent gradients compared to DXT3.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_RGTC_R = 20
Format de texture utilisant la Compression de texture Rouge Vert, normalisant les données du canal rouge en utilisant le même algorithme de compression que DXT5 utilise pour le canal alpha.
Format FORMAT_RGTC_RG = 21
Format de texture utilisant la Compression de texture Rouge Vert, normalisant les données du canal rouge et vert en utilisant le même algorithme de compression que DXT5 utilise pour le canal alpha.
Format FORMAT_BPTC_RGBA = 22
Texture format that uses BPTC compression with unsigned normalized RGBA components.
Note: When creating an ImageTexture, a nonlinear sRGB to linear encoding conversion is performed.
Format FORMAT_BPTC_RGBF = 23
Le format de texture qui utilise la compression BPTC avec des flottants signés pour les composants RGB.
Format FORMAT_BPTC_RGBFU = 24
Le format de texture qui utilise la compression BPTC avec des flottants non-signés pour les composants RGB.
Format FORMAT_ETC = 25
Format de compression de texture Ericsson 1, aussi connu sous le nom d'"ETC1", et fait partie de la norme graphique OpenGL ES. Ce format ne peut stocker de canal alpha.
Format FORMAT_ETC2_R11 = 26
Format de compression de texture Ericsson 2 (variante de R11_EAC), qui fournit un canal de données non signées.
Format FORMAT_ETC2_R11S = 27
Format de compression de texture Ericsson 2 (variante de SIGNED_R11_EAC), qui fournit un canal de données signées.
Format FORMAT_ETC2_RG11 = 28
Format de compression de texture Ericsson 2 (variante de RG11_EAC), qui fournit deux canaux de données non signées.
Format FORMAT_ETC2_RG11S = 29
Format de compression de texture Ericsson 2 (variante de SIGNED_RG11_EAC), qui fournit deux canaux de données non signées.
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
Format de compression Ericsson 2 (variante de RGBA8), qui compresse les données RA et l'interprète en deux canaux (rouge et vert). Voir aussi FORMAT_ETC2_RGBA8.
Format FORMAT_DXT5_RA_AS_RG = 34
Le format de texture S3TC aussi connu sous le nom de Block Compression 3 ou BC3, qui compresse les données RA et l'interprète en deux canaux (rouge et vert). Voir aussi FORMAT_DXT5.
Format FORMAT_ASTC_4x4 = 35
Adaptive Scalable Texture Compression. This implements the 4×4 (high quality) mode.
Format FORMAT_ASTC_4x4_HDR = 36
Même format que FORMAT_ASTC_4x4, mais avec l'indice pour indiquer au GPU qu'il est utilisé pour de l'HDR.
Format FORMAT_ASTC_8x8 = 37
Adaptive Scalable Texture Compression. This implements the 8×8 (low quality) mode.
Format FORMAT_ASTC_8x8_HDR = 38
Même format que FORMAT_ASTC_8x8, mais avec l'indice pour indiquer au GPU qu'il est utilisé pour de l'HDR.
Format FORMAT_R16 = 39
OpenGL texture format GL_R16 where there's one component, a 16-bit unsigned normalized integer value. Since the value is normalized, each component is clamped between 0.0 and 1.0 (inclusive).
Note: Due to limited hardware support, it is mainly recommended to be used on desktop or console devices. It may be unsupported on mobile or web, and will consequently be converted to FORMAT_RF.
Format FORMAT_RG16 = 40
OpenGL texture format GL_RG16 where there are two components, each a 16-bit unsigned normalized integer value. Since the value is normalized, each component is clamped between 0.0 and 1.0 (inclusive).
Note: Due to limited hardware support, it is mainly recommended to be used on desktop or console devices. It may be unsupported on mobile or web, and will consequently be converted to FORMAT_RGF.
Format FORMAT_RGB16 = 41
OpenGL texture format GL_RGB16 where there are three components, each a 16-bit unsigned normalized integer value. Since the value is normalized, each component is clamped between 0.0 and 1.0 (inclusive).
Note: Due to limited hardware support, it is mainly recommended to be used on desktop or console devices. It may be unsupported on mobile or web, and will consequently be converted to FORMAT_RGBF.
Format FORMAT_RGBA16 = 42
OpenGL texture format GL_RGBA16 where there are four components, each a 16-bit unsigned normalized integer value. Since the value is normalized, each component is clamped between 0.0 and 1.0 (inclusive).
Note: Due to limited hardware support, it is mainly recommended to be used on desktop or console devices. It may be unsupported on mobile or web, and will consequently be converted to FORMAT_RGBAF.
Format FORMAT_R16I = 43
OpenGL texture format GL_R16UI where there's one component, a 16-bit unsigned integer value. Each component is clamped between 0 and 65535 (inclusive).
Note: When used in a shader, the texture requires usage of usampler samplers. Additionally, it only supports nearest-neighbor filtering under the Compatibility renderer.
Note: When sampling using get_pixel(), returned Colors have to be divided by 65535 to get the correct color value.
Format FORMAT_RG16I = 44
OpenGL texture format GL_RG16UI where there are two components, each a 16-bit unsigned integer value. Each component is clamped between 0 and 65535 (inclusive).
Note: When used in a shader, the texture requires usage of usampler samplers. Additionally, it only supports nearest-neighbor filtering under the Compatibility renderer.
Note: When sampling using get_pixel(), returned Colors have to be divided by 65535 to get the correct color value.
Format FORMAT_RGB16I = 45
OpenGL texture format GL_RGB16UI where there are three components, each a 16-bit unsigned integer value. Each component is clamped between 0 and 65535 (inclusive).
Note: When used in a shader, the texture requires usage of usampler samplers. Additionally, it only supports nearest-neighbor filtering under the Compatibility renderer.
Note: When sampling using get_pixel(), returned Colors have to be divided by 65535 to get the correct color value.
Format FORMAT_RGBA16I = 46
OpenGL texture format GL_RGBA16UI where there are four components, each a 16-bit unsigned integer value. Each component is clamped between 0 and 65535 (inclusive).
Note: When used in a shader, the texture requires usage of usampler samplers. Additionally, it only supports nearest-neighbor filtering under the Compatibility renderer.
Note: When sampling using get_pixel(), returned Colors have to be divided by 65535 to get the correct color value.
Format FORMAT_MAX = 47
Représente la taille de l'énumération Format.
enum Interpolation: 🔗
Interpolation INTERPOLATE_NEAREST = 0
Fait une interpolation du voisin le plus proche. Si l'image est redimensionnée, elle sera pixelisée.
Interpolation INTERPOLATE_BILINEAR = 1
Fait une interpolation bilinéaire. Si l'image est redimensionnée, elle peut être floue. Ce mode est plus rapide que INTERPOLATE_CUBIC, mais le résultat est moins bon.
Interpolation INTERPOLATE_CUBIC = 2
Fait une interpolation cubique. Si l'image est redimensionnée, elle peut être floue. Ce mode donne en général de meilleurs résultats que INTERPOLATE_BILINEAR, mais est plus lente.
Interpolation INTERPOLATE_TRILINEAR = 3
Effectue une interpolation bilinéaire séparément sur les deux niveaux de mipmap les plus adaptés, puis effectue une interpolation linéaire entre eux.
Cela est plus lent que INTERPOLATE_BILINEAR, mais produit des résultats de qualité supérieure avec beaucoup moins d’artefacts de crénelage.
Si l'image n'a pas de mipmaps, elles seront générées et utilisées en interne, mais aucune mipmap ne sera générée sur l'image résultante.
Note : Si vous avez l'intention de redimensionner plusieurs copies de l'image d'origine, il est préférable d'appeler generate_mipmaps() à l'avance, pour éviter de gaspiller de la puissance de traitement pour les générer encore et encore.
D'autre part, si l'image a déjà des mipmaps, elles seront utilisées, et un nouveau jeu sera généré pour l'image résultante.
Interpolation INTERPOLATE_LANCZOS = 4
Effectue une interpolation de Lanczos. Il s'agit du mode le plus lent de redimensionnement d'image, mais il donne généralement les meilleurs résultats, surtout lors de la réduction d'images.
enum AlphaMode: 🔗
AlphaMode ALPHA_NONE = 0
Image is fully opaque. It does not store alpha data.
AlphaMode ALPHA_BIT = 1
Image stores either fully opaque or fully transparent pixels. Also known as punchthrough alpha.
AlphaMode ALPHA_BLEND = 2
Image stores alpha data with values varying between 0.0 and 1.0.
enum CompressMode: 🔗
CompressMode COMPRESS_S3TC = 0
Utiliser la compression ST3TC.
CompressMode COMPRESS_ETC = 1
Utiliser la compression ETC.
CompressMode COMPRESS_ETC2 = 2
Utiliser la compression ETC2.
CompressMode COMPRESS_BPTC = 3
Utiliser la compression BPTC.
CompressMode COMPRESS_ASTC = 4
Utiliser la compression ASTC.
CompressMode COMPRESS_MAX = 5
Représente la taille de l'énumération CompressMode.
enum UsedChannels: 🔗
UsedChannels USED_CHANNELS_L = 0
L'image n'utilise qu'un canal pour la luminance (niveaux de gris).
UsedChannels USED_CHANNELS_LA = 1
L'image utilise deux canaux pour la luminance et l'alpha, respectivement.
UsedChannels USED_CHANNELS_R = 2
L'image n'utilise que le canal rouge.
UsedChannels USED_CHANNELS_RG = 3
L'image utilise deux canaux pour le rouge et le vert.
UsedChannels USED_CHANNELS_RGB = 4
L'image utilise trois canaux pour le rouge, le vert et le bleu.
UsedChannels USED_CHANNELS_RGBA = 5
L'image utilise quatre canaux pour le rouge, le vert, le bleu et l'alpha.
enum CompressSource: 🔗
CompressSource COMPRESS_SOURCE_GENERIC = 0
La texture d'origine (avant la compression) est une texture classique. C'est le choix par défaut de toutes les textures.
CompressSource COMPRESS_SOURCE_SRGB = 1
Source texture (before compression) uses nonlinear sRGB encoding.
CompressSource COMPRESS_SOURCE_NORMAL = 2
La texture d'origine (avant la compression) est une texture pour les normales (elle peut être compressée en n'utilisant que deux canaux).
enum ASTCFormat: 🔗
ASTCFormat ASTC_FORMAT_4x4 = 0
Indice indiquant que le format de compression 4×4 ASTC haute qualité devrait être utilisé.
ASTCFormat ASTC_FORMAT_8x8 = 1
Indice indiquant que le format de compression 8×8 ASTC basse qualité devrait être utilisé.
Constantes
MAX_WIDTH = 16777216 🔗
La largeur maximale autorisée pour les Image.
MAX_HEIGHT = 16777216 🔗
La hauteur maximale autorisée pour les Image.
Descriptions des propriétés
Dictionary data = { "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 } 🔗
Garde tous les données de couleur de l'image dans un format donné. Voir les constantes Format.
Descriptions des méthodes
void adjust_bcs(brightness: float, contrast: float, saturation: float) 🔗
Ajuste la luminosité brightness, le contraste contrast et la saturation de l'image par les valeurs données. Ne fonctionne pas si l'image est compressée (voir is_compressed()).
void blend_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Effectue un mélange alpha entre le rectangle src_rect de l'image src et cette image aux coordonnées dst, coupé selon les deux limites des images. Cette image et src doivent avoir le même format. Un src_rect avec une taille non positive est considéré comme vide.
void blend_rect_mask(src: Image, mask: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Effectue un mélange alpha entre le rectangle src_rect de l'image src et cette image en utilisant l'image mask aux coordonnées dst, coupé selon les deux limites des images. Les canaux alpha sont requis pour src et mask. Les pixels de dst et les pixels de src se mélangeront si la valeur alpha du masque correspondant n'est pas 0. Cette image et src doivent avoir le même format. L'image src et l'image mask doivent doivent avoir la même taille (largeur et hauteur) mais ils peuvent avoir des formats différents. Un src_rect avec une taille non positive est considéré comme vide.
void blit_rect(src: Image, src_rect: Rect2i, dst: Vector2i) 🔗
Copie le rectangle src_rect de l'image src vers cette image aux coordonnées dst, coupé selon les deux limites des images. Cette image et l'image src doivent avoir le même format. Un src_rect avec une taille non positive est considéré comme vide.
Note : Les données du canal alpha dans src écraseront les données correspondantes dans cette image à la position cible. Pour mélanger les canaux alpha, utilisez plutôt blend_rect().
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) 🔗
Convertit une bump map en une normal map. Une bump map fournit un décalage de hauteur par pixel, tandis qu'une normal map fournit une direction normale par pixel.
void clear_mipmaps() 🔗
Retire les mipmaps de l'image.
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) 🔗
Compute image metrics on the current image and the compared image. This can be used to calculate the similarity between two images.
The dictionary contains max, mean, mean_squared, root_mean_squared and peak_snr.
void convert(format: Format) 🔗
Convertit le format de cette image au format format donné.
Copie l'image src vers cette image.
Image create(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗
Obsolète : Use create_empty().
Creates an empty image of the given size and format. If use_mipmaps is true, generates mipmaps for this image (see generate_mipmaps()).
Image create_empty(width: int, height: int, use_mipmaps: bool, format: Format) static 🔗
Creates an empty image of the given size and format. If use_mipmaps is true, generates mipmaps for this image (see generate_mipmaps()).
Image create_from_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) static 🔗
Crée une nouvelle image de la taille et du format donnés. Remplit l'image avec les données brutes données. Si use_mipmaps vaut true, charge les mipmaps pour cette image de data. Voir generate_mipmaps().
void crop(width: int, height: int) 🔗
Recadre l'image à la largeur width et hauteur height données. Si la taille spécifiée est plus grande que la taille actuelle, la zone supplémentaire est remplie de pixels noirs.
Decompresses the image if it is VRAM-compressed in a supported format. This increases memory utilization, but allows modifying the image. Returns @GlobalScope.OK if the format is supported, otherwise @GlobalScope.ERR_UNAVAILABLE. All VRAM-compressed formats supported by Godot can be decompressed with this method, except FORMAT_ETC2_R11S, FORMAT_ETC2_RG11S, and FORMAT_ETC2_RGB8A1.
AlphaMode detect_alpha() const 🔗
Renvoie ALPHA_BLEND si l’image a des données pour les valeurs alpha. Renvoie ALPHA_BIT si toutes les valeurs alpha sont stockées en un seul bit. Renvoie ALPHA_NONE si aucune donnée pour les valeurs alpha n’est trouvée.
UsedChannels detect_used_channels(source: CompressSource = 0) const 🔗
Renvoie les canaux de couleur utilisés par cette image. Si l'image est compressée, la source originelle doit être spécifiée.
Remplit toute l'image avec la couleur color.
void fill_rect(rect: Rect2i, color: Color) 🔗
Remplit le rect avec la color.
void fix_alpha_edges() 🔗
Mélange les pixels à faible opacité (alpha) avec ceux proches.
void flip_x() 🔗
Inverse l'image horizontalement.
void flip_y() 🔗
Inverse l'image verticalement.
Error generate_mipmaps(renormalize: bool = false) 🔗
Génère des mipmaps pour l'image. Les mipmaps sont des copies précalculées en basse résolution de l'image qui sont automatiquement utilisées si l'image doit être réduite au moment du rendu. Ils aident à améliorer la qualité de l'image et la performance lors du rendu. Cette méthode renvoie une erreur si l'image est compressée, dans un format personnalisé, ou si la largeur/hauteur de l'image vaut 0. Activer renormalize lors de la génération des mipmaps pour les textures de normal map assurera que toutes les valeurs vectorielles résultantes sont normalisées.
Il est possible de vérifier si l'image a des mipmaps en appelant has_mipmaps() ou get_mipmap_count(). Appeler generate_mipmaps() sur une image qui a déjà des mipmaps remplacera les mipmaps existantes dans l'image.
PackedByteArray get_data() const 🔗
Renvoie une copie des données brutes de l’image.
Renvoie la taille (en octets) des données brutes de l'image.
Renvoie le format de cette image.
Renvoie la hauteur de l'image.
int get_mipmap_count() const 🔗
Renvoie le nombre de niveaux de mipmap ou 0 si l'image n'a pas de mipmaps. L'image de niveau principal la plus grande n'est pas comptée comme un niveau de mipmap par cette méthode, donc si vous voulez l'inclure, vous pouvez ajouter 1 à ce nombre.
int get_mipmap_offset(mipmap: int) const 🔗
Renvoie le décalage où la mipmap de l'image avec l'index mipmap est stockée dans le dictionnaire data.
Color get_pixel(x: int, y: int) const 🔗
Renvoie la couleur du pixel à (x, y).
C'est la même chose que get_pixelv(), mais avec deux arguments entiers au lieu d'un argument Vector2i.
Color get_pixelv(point: Vector2i) const 🔗
Renvoie la couleur du pixel au point donné.
C'est la même chose que get_pixel(), mais avec un argument Vector2i au lieu de deux arguments entiers.
Image get_region(region: Rect2i) const 🔗
Renvoie une nouvelle Image qui est une copie de la zone de cette Image spécifiée par region.
Renvoie la taille de l'image (la largeur et la hauteur).
Rect2i get_used_rect() const 🔗
Renvoie un Rect2i contenant la partie visible de l'image, en considérant chaque pixel avec un canal alpha non nul comme visible.
Renvoie la largeur de l'image.
Renvoie true si l'image a des mipmaps générées.
Renvoie true si l'image est compressée.
Renvoie true si l'image n'a aucune données.
Renvoie true si tous les pixels de l'image ont une valeur alpha de 0. Renvoie false si au moins un pixel a une valeur alpha supérieure à 0.
void linear_to_srgb() 🔗
Converts the entire image from linear encoding to nonlinear sRGB encoding by using a lookup table. Only works on images with FORMAT_RGB8 or FORMAT_RGBA8 formats.
Charge une image depuis le fichier path. Voir Formats d'image pris en charge pour une liste des formats d'image pris en charge et les limitations.
Attention : Cette méthode ne devrait être utilisée que dans l'éditeur ou dans les cas où vous devez charger des images externes durant l'exécution, comme des images situées dans le répertoire user://, et peut ne pas fonctionner dans des projets exportés.
Voir aussi la description de ImageTexture pour des exemples d'utilisation.
Error load_bmp_from_buffer(buffer: PackedByteArray) 🔗
Charge une image à partir du contenu binaire d'un fichier BMP.
Note : Le module BMP de Godot ne supporte pas les images de 16 bits par pixel. Seulement les images de 1-bit, 4-bit, 8-bit, 24-bit et 32-bit par pixel sont prises en charge.
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module BMP activé. Par défaut, le module BMP est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_bmp_enabled=no.
Error load_dds_from_buffer(buffer: PackedByteArray) 🔗
Charge une image à partir du contenu binaire d'un fichier DDS.
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module DDS activé. Par défaut, le module DDS est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_dds_enabled=no.
Error load_exr_from_buffer(buffer: PackedByteArray) 🔗
Loads an image from the binary contents of an OpenEXR file.
Image load_from_file(path: String) static 🔗
Crée une nouvelle Image et charge les données depuis le fichier spécifié.
Error load_jpg_from_buffer(buffer: PackedByteArray) 🔗
Charge une image à partir du contenu binaire d’un fichier JPEG.
Error load_ktx_from_buffer(buffer: PackedByteArray) 🔗
Charge une image du contenu binaire d'un fichier KTX. Contrairement à la plupart des formats d'image, KTX peut stocker des données compressées VRAM et des mipmaps intégrées.
Note : L'implémentation libktx de Godot ne supporte que les images 2D. Les cubemaps, les tableaux de texture et le de-padding ne sont pas pris en charge.
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module KTX activé. Par défaut, le module KTX est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_ktx_enabled=no.
Error load_png_from_buffer(buffer: PackedByteArray) 🔗
Charge une image à partir du contenu binaire d'un fichier PNG.
Error load_svg_from_buffer(buffer: PackedByteArray, scale: float = 1.0) 🔗
Charge une image du contenu binaire UTF-8 d'un fichier SVG décompressé (.svg).
Note : Attention à l'utilisation de fichiers SVG compressés (comme .svgz), ils doivent être décompressés avant le chargement.
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module SVG activé. Par défaut, le module SVG est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_svg_enabled=no.
Error load_svg_from_string(svg_str: String, scale: float = 1.0) 🔗
Charge une image à partir du contenu de chaîne d'un fichier SVG (.svg).
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module SVG activé. Par défaut, le module SVG est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_svg_enabled=no.
Error load_tga_from_buffer(buffer: PackedByteArray) 🔗
Charge une image à partir du contenu binaire d'un fichier TGA.
Note : Cette méthode n'est disponible que dans les compilation du moteur avec le module TGA activé. Par défaut, le module TGA est activé, mais il peut être désactivé durant la compilation en utilisant l'option SCons module_tga_enabled=no.
Error load_webp_from_buffer(buffer: PackedByteArray) 🔗
Charge une image depuis le contenu binaire d'un fichier WebP.
void normal_map_to_xy() 🔗
Convertit les données de l'image pour représenter des coordonnées sur un plan 3D. Ceci est utilisé lorsque l'image représente une normal map. Une normal map peut ajouter beaucoup de détail à une surface 3D sans augmenter le nombre de polygones.
void premultiply_alpha() 🔗
Multiplie les valeurs de couleur avec les valeurs alpha. Les valeurs de couleur résultantes pour un pixel sont (color * alpha)/256. Voir aussi 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) 🔗
Redimensionne l'image à la puissance de 2 la plus proche pour la largeur et la hauteur. Si square vaut true, fixe la largeur et la hauteur pour être identiques. Les nouveaux pixels sont calculés à l'aide du mode d'interpolation défini via les constantes Interpolation.
Converts a standard linear RGBE (Red Green Blue Exponent) image to an image that uses nonlinear sRGB encoding.
void rotate_90(direction: ClockDirection) 🔗
Pivote l'image dans la direction spécifiée de 90 degrés. La largeur et la hauteur de l'image doivent être supérieures à 1. Si la largeur et la hauteur ne sont pas égales, l'image sera redimensionnée.
void rotate_180() 🔗
Pivote l'image de 180 degrés. La largeur et la hauteur de l'image doivent être supérieures à 1.
Error save_dds(path: String) const 🔗
Sauvegarde l'image comme un fichier DDS (DirectDraw Surface) au chemin path. DDS est un format conteneur qui peut stocker des textures dans divers formats de compression, tels que DXT1, DXT5, ou BC7. Cette fonction renverra @GlobalScope.ERR_UNAVAILABLE si Godot a été compilé sans le module DDS.
Note : Le module DDS peut être désactivé dans certaines compilations, ce qui signifie que save_dds() renverra @GlobalScope.ERR_UNAVAILABLE lorsqu'elle est appelée à partir d'un projet exporté.
PackedByteArray save_dds_to_buffer() const 🔗
Sauvegarde l'image comme un fichier DDS (DirectDraw Surface) en un tableau d'octets. DDS est un format conteneur qui peut stocker des textures dans divers formats de compression, tels que DXT1, DXT5, ou BC7. Cette fonction renverra un tableau d'octets vide si Godot a été compilé sans le module DDS.
Note : Le module DDS peut être désactivé dans certaines compilations, ce qui signifie que save_dds_to_buffer() renverra un tableau d'octets vide lorsqu'elle est appelée à partir d'un projet exporté.
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 🔗
Enregistre l'image en tant que fichier JPEG vers le chemin path avec la qualité quality spécifiée entre 0.01 et 1.0 (inclusifs). Des valeurs plus élevées de quality résultent en une meilleure performance au coût de plus grandes tailles de fichiers. Les valeurs recommandées pour quality sont comprises entre 0.75 et 0.90. Même à la qualité 1.00, la compression JPEG reste avec pertes.
Note : Le JPEG ne sauvegarde pas de canal alpha. Si l'Image contient un canal alpha, l'image sera toujours sauvegardée, mais le fichier JPEG résultant ne contiendra pas le canal alpha.
PackedByteArray save_jpg_to_buffer(quality: float = 0.75) const 🔗
Enregistre l'image en tant que fichier JPEG en un tableau d'octets avec la qualité quality spécifiée entre 0.01 et 1.0 (inclusifs). Des valeurs plus élevées de quality résultent en une meilleure performance au coût de plus grandes tailles de fichiers. Les valeurs recommandées pour quality sont comprises entre 0.75 et 0.90. Même à la qualité 1.00, la compression JPEG reste avec pertes.
Note : Le JPEG ne sauvegarde pas de canal alpha. Si l'Image contient un canal alpha, l'image sera toujours sauvegardée, mais le tableau d'octets résultant ne contiendra pas le canal alpha.
Error save_png(path: String) const 🔗
Enregistre l'image en un fichier PNG à l'emplacement path.
PackedByteArray save_png_to_buffer() const 🔗
Enregistre l'image comme un fichier PNG vers un tableau d'octets.
Error save_webp(path: String, lossy: bool = false, quality: float = 0.75) const 🔗
Enregistre l'image en tant que fichier WebP (Web Picture) vers le fichier au chemin path. Par défaut, la sauvegarde sera sans perte. Si lossy vaut true, l'image sera sauvegardée en utilisant le paramètre de qualité quality entre 0.0 et 1.0 (inclusifs). Le WebP sans perte offre une compression plus efficace que le PNG.
Note : Le format WebP est limité à une taille de 16383×16383 pixels, tandis que le PNG peut enregistrer des images plus grandes.
PackedByteArray save_webp_to_buffer(lossy: bool = false, quality: float = 0.75) const 🔗
Enregistre l'image en tant que fichier WebP (Web Picture) en un tableau d'octets. Par défaut, la sauvegarde sera sans perte. Si lossy vaut true, l'image sera sauvegardée en utilisant le paramètre de qualité quality entre 0.0 et 1.0 (inclusifs). Le WebP sans perte offre une compression plus efficace que le PNG.
Note : Le format WebP est limité à une taille de 16383×16383 pixels, tandis que le PNG peut enregistrer des images plus grandes.
void set_data(width: int, height: int, use_mipmaps: bool, format: Format, data: PackedByteArray) 🔗
Écrase les données d'une Image existante. Équivalent non statique 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.
Note: Depending on the image's format, the color set here may be clamped or lose precision. Do not assume the color returned by get_pixel() to be identical to the one set here; any comparisons will likely need to use an approximation like Color.is_equal_approx().
Note: On grayscale image formats, only the red channel of color is used (and alpha if relevant). The green and blue channels are ignored.
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.
Note: Depending on the image's format, the color set here may be clamped or lose precision. Do not assume the color returned by get_pixelv() to be identical to the one set here; any comparisons will likely need to use an approximation like Color.is_equal_approx().
Note: On grayscale image formats, only the red channel of color is used (and alpha if relevant). The green and blue channels are ignored.
void shrink_x2() 🔗
Rétrécit l'image par un facteur 2 sur chaque axe (ceci divise le nombre de pixels par 4).
void srgb_to_linear() 🔗
Converts the raw data from nonlinear sRGB encoding to linear encoding using a lookup table. Only works on images with FORMAT_RGB8 or FORMAT_RGBA8 formats.
Note: The 8-bit formats required by this method are not suitable for storing linearly encoded values; a significant amount of color information will be lost in darker values. To maintain image quality, this method should not be used.