godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.5
godot-docs-l10n/classes/fr/class_image.rst
Rémi Verschelde 369fd84a4f Sync classref with 4.5 branch
2025-12-19 14:34:07 +01:00

1887 lines
114 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_Image:
Image
=====
**Hérite de :** :ref:`Resource<class_Resource>` **<** :ref:`RefCounted<class_RefCounted>` **<** :ref:`Object<class_Object>`
Type de données d’image.
.. rst-class:: classref-introduction-group
Description
-----------
Type de données d'image native. Contient des données d'image qui peuvent être converties en une :ref:`ImageTexture<class_ImageTexture>` et fournit des méthodes de *traitement d'image* couramment utilisées. La largeur et la hauteur maximales pour une **Image** sont :ref:`MAX_WIDTH<class_Image_constant_MAX_WIDTH>` et :ref:`MAX_HEIGHT<class_Image_constant_MAX_HEIGHT>`.
Une **Image** ne peut être attribuée à une propriété de texture d'un objet directement (comme :ref:`Sprite2D.texture<class_Sprite2D_property_texture>`), et doit être convertie manuellement en une :ref:`ImageTexture<class_ImageTexture>` d'abord.
\ **Note :** La taille maximale de l'image est de 16384×16384 pixels en raison des limitations de matériel graphiques. Les images plus grandes peuvent échouer à l'import.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- :doc:`Importer des images <../tutorials/assets_pipeline/importing_images>`
- :doc:`Chargement et sauvegarde de fichiers durant l’exécution <../tutorials/io/runtime_file_loading_and_saving>`
.. rst-class:: classref-reftable-group
Propriétés
--------------------
.. table::
:widths: auto
+-------------------------------------+----------------------------------------+------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_Dictionary>` | :ref:`data<class_Image_property_data>` | ``{ "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 }`` |
+-------------------------------------+----------------------------------------+------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`adjust_bcs<class_Image_method_adjust_bcs>`\ (\ brightness\: :ref:`float<class_float>`, contrast\: :ref:`float<class_float>`, saturation\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`blend_rect<class_Image_method_blend_rect>`\ (\ src\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`blend_rect_mask<class_Image_method_blend_rect_mask>`\ (\ src\: :ref:`Image<class_Image>`, mask\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`blit_rect<class_Image_method_blit_rect>`\ (\ src\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`blit_rect_mask<class_Image_method_blit_rect_mask>`\ (\ src\: :ref:`Image<class_Image>`, mask\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bump_map_to_normal_map<class_Image_method_bump_map_to_normal_map>`\ (\ bump_scale\: :ref:`float<class_float>` = 1.0\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear_mipmaps<class_Image_method_clear_mipmaps>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`compress<class_Image_method_compress>`\ (\ mode\: :ref:`CompressMode<enum_Image_CompressMode>`, source\: :ref:`CompressSource<enum_Image_CompressSource>` = 0, astc_format\: :ref:`ASTCFormat<enum_Image_ASTCFormat>` = 0\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`compress_from_channels<class_Image_method_compress_from_channels>`\ (\ mode\: :ref:`CompressMode<enum_Image_CompressMode>`, channels\: :ref:`UsedChannels<enum_Image_UsedChannels>`, astc_format\: :ref:`ASTCFormat<enum_Image_ASTCFormat>` = 0\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Dictionary<class_Dictionary>` | :ref:`compute_image_metrics<class_Image_method_compute_image_metrics>`\ (\ compared_image\: :ref:`Image<class_Image>`, use_luma\: :ref:`bool<class_bool>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`convert<class_Image_method_convert>`\ (\ format\: :ref:`Format<enum_Image_Format>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`copy_from<class_Image_method_copy_from>`\ (\ src\: :ref:`Image<class_Image>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`create<class_Image_method_create>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`\ ) |static| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`create_empty<class_Image_method_create_empty>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`\ ) |static| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`create_from_data<class_Image_method_create_from_data>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |static| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`crop<class_Image_method_crop>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`decompress<class_Image_method_decompress>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`AlphaMode<enum_Image_AlphaMode>` | :ref:`detect_alpha<class_Image_method_detect_alpha>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`UsedChannels<enum_Image_UsedChannels>` | :ref:`detect_used_channels<class_Image_method_detect_used_channels>`\ (\ source\: :ref:`CompressSource<enum_Image_CompressSource>` = 0\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill<class_Image_method_fill>`\ (\ color\: :ref:`Color<class_Color>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill_rect<class_Image_method_fill_rect>`\ (\ rect\: :ref:`Rect2i<class_Rect2i>`, color\: :ref:`Color<class_Color>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fix_alpha_edges<class_Image_method_fix_alpha_edges>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`flip_x<class_Image_method_flip_x>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`flip_y<class_Image_method_flip_y>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`generate_mipmaps<class_Image_method_generate_mipmaps>`\ (\ renormalize\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`get_data<class_Image_method_get_data>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_data_size<class_Image_method_get_data_size>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Format<enum_Image_Format>` | :ref:`get_format<class_Image_method_get_format>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_height<class_Image_method_get_height>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_mipmap_count<class_Image_method_get_mipmap_count>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_mipmap_offset<class_Image_method_get_mipmap_offset>`\ (\ mipmap\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`get_pixel<class_Image_method_get_pixel>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`get_pixelv<class_Image_method_get_pixelv>`\ (\ point\: :ref:`Vector2i<class_Vector2i>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`get_region<class_Image_method_get_region>`\ (\ region\: :ref:`Rect2i<class_Rect2i>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Vector2i<class_Vector2i>` | :ref:`get_size<class_Image_method_get_size>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Rect2i<class_Rect2i>` | :ref:`get_used_rect<class_Image_method_get_used_rect>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_width<class_Image_method_get_width>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_mipmaps<class_Image_method_has_mipmaps>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_compressed<class_Image_method_is_compressed>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_Image_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_invisible<class_Image_method_is_invisible>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`linear_to_srgb<class_Image_method_linear_to_srgb>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load<class_Image_method_load>`\ (\ path\: :ref:`String<class_String>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_bmp_from_buffer<class_Image_method_load_bmp_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_dds_from_buffer<class_Image_method_load_dds_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`load_from_file<class_Image_method_load_from_file>`\ (\ path\: :ref:`String<class_String>`\ ) |static| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_jpg_from_buffer<class_Image_method_load_jpg_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_ktx_from_buffer<class_Image_method_load_ktx_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_png_from_buffer<class_Image_method_load_png_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_svg_from_buffer<class_Image_method_load_svg_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, scale\: :ref:`float<class_float>` = 1.0\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_svg_from_string<class_Image_method_load_svg_from_string>`\ (\ svg_str\: :ref:`String<class_String>`, scale\: :ref:`float<class_float>` = 1.0\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_tga_from_buffer<class_Image_method_load_tga_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`load_webp_from_buffer<class_Image_method_load_webp_from_buffer>`\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`normal_map_to_xy<class_Image_method_normal_map_to_xy>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`premultiply_alpha<class_Image_method_premultiply_alpha>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`resize<class_Image_method_resize>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, interpolation\: :ref:`Interpolation<enum_Image_Interpolation>` = 1\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`resize_to_po2<class_Image_method_resize_to_po2>`\ (\ square\: :ref:`bool<class_bool>` = false, interpolation\: :ref:`Interpolation<enum_Image_Interpolation>` = 1\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Image<class_Image>` | :ref:`rgbe_to_srgb<class_Image_method_rgbe_to_srgb>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`rotate_90<class_Image_method_rotate_90>`\ (\ direction\: :ref:`ClockDirection<enum_@GlobalScope_ClockDirection>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`rotate_180<class_Image_method_rotate_180>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`save_dds<class_Image_method_save_dds>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`save_dds_to_buffer<class_Image_method_save_dds_to_buffer>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`save_exr<class_Image_method_save_exr>`\ (\ path\: :ref:`String<class_String>`, grayscale\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`save_exr_to_buffer<class_Image_method_save_exr_to_buffer>`\ (\ grayscale\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`save_jpg<class_Image_method_save_jpg>`\ (\ path\: :ref:`String<class_String>`, quality\: :ref:`float<class_float>` = 0.75\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`save_jpg_to_buffer<class_Image_method_save_jpg_to_buffer>`\ (\ quality\: :ref:`float<class_float>` = 0.75\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`save_png<class_Image_method_save_png>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`save_png_to_buffer<class_Image_method_save_png_to_buffer>`\ (\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Error<enum_@GlobalScope_Error>` | :ref:`save_webp<class_Image_method_save_webp>`\ (\ path\: :ref:`String<class_String>`, lossy\: :ref:`bool<class_bool>` = false, quality\: :ref:`float<class_float>` = 0.75\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`save_webp_to_buffer<class_Image_method_save_webp_to_buffer>`\ (\ lossy\: :ref:`bool<class_bool>` = false, quality\: :ref:`float<class_float>` = 0.75\ ) |const| |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_data<class_Image_method_set_data>`\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_pixel<class_Image_method_set_pixel>`\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set_pixelv<class_Image_method_set_pixelv>`\ (\ point\: :ref:`Vector2i<class_Vector2i>`, color\: :ref:`Color<class_Color>`\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`shrink_x2<class_Image_method_shrink_x2>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`srgb_to_linear<class_Image_method_srgb_to_linear>`\ (\ ) |
+-----------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Énumérations
------------------------
.. _enum_Image_Format:
.. rst-class:: classref-enumeration
enum **Format**: :ref:`🔗<enum_Image_Format>`
.. _class_Image_constant_FORMAT_L8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_L8** = ``0``
Un format de texture 8-bit représentant la luminance (niveaux de gris).
.. _class_Image_constant_FORMAT_LA8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_LA8** = ``1``
Format de texture OpenGL avec deux composantes, la luminance et l'opacité, chacune sur 8 bits.
.. _class_Image_constant_FORMAT_R8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_R8** = ``2``
Format de texture OpenGL ``RED`` avec une unique composante sur 8 bits.
.. _class_Image_constant_FORMAT_RG8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RG8** = ``3``
Format de texture OpenGL ``RG`` avec deux composantes, chacune sur 8 bits.
.. _class_Image_constant_FORMAT_RGB8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGB8** = ``4``
Format de texture OpenGL ``RGB`` avec trois composantes, chacune sur 8 bits.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion sRGB vers l'espace de couleur linéaire est effectuée.
.. _class_Image_constant_FORMAT_RGBA8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGBA8** = ``5``
Format de texture OpenGL ``RGBA`` avec quatre composantes, chacune sur 8 bits.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion sRGB vers l'espace de couleur linéaire est effectuée.
.. _class_Image_constant_FORMAT_RGBA4444:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGBA4444** = ``6``
Format de texture OpenGL ``RGBA`` où il y a quatre composantes, chacune sur 4 bits.
.. _class_Image_constant_FORMAT_RGB565:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGB565** = ``7``
Format de texture OpenGL ``RGB`` avec trois composantes. Rouge et bleu sont sur 5 bits, et vert sur 6.
.. _class_Image_constant_FORMAT_RF:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RF** = ``8``
Format de texture OpenGL ``GL_R32F`` où il n'y a qu'un seul composante, un flottant de 32 bits.
.. _class_Image_constant_FORMAT_RGF:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGF** = ``9``
Format de texture OpenGL ``GL_RG32F`` où il y a deux composantes, chacune un flottant de 32 bits.
.. _class_Image_constant_FORMAT_RGBF:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGBF** = ``10``
Format de texture OpenGL ``GL_RGB32F`` où il y a trois composantes, chacune un flottant de 32 bits.
.. _class_Image_constant_FORMAT_RGBAF:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGBAF** = ``11``
Format de texture OpenGL ``GL_RGBA32F`` où il y a quatre composantes, chacune un flottant de 32 bits.
.. _class_Image_constant_FORMAT_RH:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_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.
.. _class_Image_constant_FORMAT_RGH:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_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.
.. _class_Image_constant_FORMAT_RGBH:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_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.
.. _class_Image_constant_FORMAT_RGBAH:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_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.
.. _class_Image_constant_FORMAT_RGBE9995:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_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.
.. _class_Image_constant_FORMAT_DXT1:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_DXT1** = ``17``
Le format de texture `S3TC <https://en.wikipedia.org/wiki/S3_Texture_Compression>`__ qui utilise Block Compression 1, et est une variation plus petite de S3TC, avec seulement 1 bit pour l'alpha et les composants de couleurs étant pré-multitpliées avec l'alpha.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_DXT3:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_DXT3** = ``18``
Le format de texture `S3TC <https://en.wikipedia.org/wiki/S3_Texture_Compression>`__ qui utilise Block Compression 2, et les données de couleur sont interprétées comme n'ayant pas été prémultipliées par l'alpha. Bien adapté aux images avec des transitions alpha nettes entre les zones translucides et les zones opaques.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_DXT5:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_DXT5** = ``19``
Le format de texture `S3TC <https://en.wikipedia.org/wiki/S3_Texture_Compression>`__ qui utilise Block Compression 3 ou BC3 qui contient 64 bits de données de canal alpha suivis de 64 bits de données de couleurs encodées en DXT1. Les données de couleur ne sont pas pré-multipliées par l'alpha, comme avec DXT3. DXT5 produit généralement des résultats supérieurs pour des gradients transparents comparé à DXT3.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_RGTC_R:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGTC_R** = ``20``
Format de texture utilisant la `Compression de texture Rouge Vert <https://www.khronos.org/opengl/wiki/Red_Green_Texture_Compression>`__, normalisant les données du canal rouge en utilisant le même algorithme de compression que DXT5 utilise pour le canal alpha.
.. _class_Image_constant_FORMAT_RGTC_RG:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_RGTC_RG** = ``21``
Format de texture utilisant la `Compression de texture Rouge Vert <https://www.khronos.org/opengl/wiki/Red_Green_Texture_Compression>`__, normalisant les données du canal rouge et vert en utilisant le même algorithme de compression que DXT5 utilise pour le canal alpha.
.. _class_Image_constant_FORMAT_BPTC_RGBA:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_BPTC_RGBA** = ``22``
Format de texture utilisant la compression `BPTC <https://www.khronos.org/opengl/wiki/BPTC_Texture_Compression>`__ avec des composantes RGBA normalisées non signées.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_BPTC_RGBF:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_BPTC_RGBF** = ``23``
Le format de texture qui utilise la compression `BPTC <https://www.khronos.org/opengl/wiki/BPTC_Texture_Compression>`__ avec des flottants signés pour les composants RGB.
.. _class_Image_constant_FORMAT_BPTC_RGBFU:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_BPTC_RGBFU** = ``24``
Le format de texture qui utilise la compression `BPTC <https://www.khronos.org/opengl/wiki/BPTC_Texture_Compression>`__ avec des flottants non-signés pour les composants RGB.
.. _class_Image_constant_FORMAT_ETC:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC** = ``25``
`Format de compression de texture Ericsson 1 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC1>`__, aussi connu sous le nom d'"ETC1", et fait partie de la norme graphique OpenGL ES. Ce format ne peut stocker de canal alpha.
.. _class_Image_constant_FORMAT_ETC2_R11:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_R11** = ``26``
`Format de compression de texture Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``R11_EAC``), qui fournit un canal de données non signées.
.. _class_Image_constant_FORMAT_ETC2_R11S:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_R11S** = ``27``
`Format de compression de texture Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``SIGNED_R11_EAC``), qui fournit un canal de données signées.
.. _class_Image_constant_FORMAT_ETC2_RG11:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RG11** = ``28``
`Format de compression de texture Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``RG11_EAC``), qui fournit deux canaux de données non signées.
.. _class_Image_constant_FORMAT_ETC2_RG11S:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RG11S** = ``29``
`Format de compression de texture Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``SIGNED_RG11_EAC``), qui fournit deux canaux de données non signées.
.. _class_Image_constant_FORMAT_ETC2_RGB8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RGB8** = ``30``
`Format de compression Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``RGB8``), qui est la suite d'ETC1 et compresse des données RGB888.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_ETC2_RGBA8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RGBA8** = ``31``
`Format de compression Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``RGBA8``), qui compresse des données RGBA8888 avec le support complet du canal alpha.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_ETC2_RGB8A1:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RGB8A1** = ``32``
`Format de compression Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``RGB8_PUNCHTHROUGH_ALPHA1``), qui compresse des données RGBA pour faire que l'alpha soit complètement transparent ou complètement opaque.
\ **Note :** Lors de la création d'une :ref:`ImageTexture<class_ImageTexture>`, une conversion de l'espace de couleur sRGB vers linéaire est effectuée.
.. _class_Image_constant_FORMAT_ETC2_RA_AS_RG:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ETC2_RA_AS_RG** = ``33``
`Format de compression Ericsson 2 <https://en.wikipedia.org/wiki/Ericsson_Texture_Compression#ETC2_and_EAC>`__ (variante de ``RGBA8``), qui compresse les données RA et l'interprète en deux canaux (rouge et vert). Voir aussi :ref:`FORMAT_ETC2_RGBA8<class_Image_constant_FORMAT_ETC2_RGBA8>`.
.. _class_Image_constant_FORMAT_DXT5_RA_AS_RG:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_DXT5_RA_AS_RG** = ``34``
Le format de texture `S3TC <https://en.wikipedia.org/wiki/S3_Texture_Compression>`__ 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 :ref:`FORMAT_DXT5<class_Image_constant_FORMAT_DXT5>`.
.. _class_Image_constant_FORMAT_ASTC_4x4:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ASTC_4x4** = ``35``
`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 4×4 (high quality) mode.
.. _class_Image_constant_FORMAT_ASTC_4x4_HDR:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ASTC_4x4_HDR** = ``36``
Même format que :ref:`FORMAT_ASTC_4x4<class_Image_constant_FORMAT_ASTC_4x4>`, mais avec l'indice pour indiquer au GPU qu'il est utilisé pour de l'HDR.
.. _class_Image_constant_FORMAT_ASTC_8x8:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ASTC_8x8** = ``37``
`Adaptive Scalable Texture Compression <https://en.wikipedia.org/wiki/Adaptive_scalable_texture_compression>`__. This implements the 8×8 (low quality) mode.
.. _class_Image_constant_FORMAT_ASTC_8x8_HDR:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_ASTC_8x8_HDR** = ``38``
Même format que :ref:`FORMAT_ASTC_8x8<class_Image_constant_FORMAT_ASTC_8x8>`, mais avec l'indice pour indiquer au GPU qu'il est utilisé pour de l'HDR.
.. _class_Image_constant_FORMAT_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`Format<enum_Image_Format>` **FORMAT_MAX** = ``39``
Représente la taille de l'énumération :ref:`Format<enum_Image_Format>`.
.. rst-class:: classref-item-separator
----
.. _enum_Image_Interpolation:
.. rst-class:: classref-enumeration
enum **Interpolation**: :ref:`🔗<enum_Image_Interpolation>`
.. _class_Image_constant_INTERPOLATE_NEAREST:
.. rst-class:: classref-enumeration-constant
:ref:`Interpolation<enum_Image_Interpolation>` **INTERPOLATE_NEAREST** = ``0``
Fait une interpolation du voisin le plus proche. Si l'image est redimensionnée, elle sera pixelisée.
.. _class_Image_constant_INTERPOLATE_BILINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`Interpolation<enum_Image_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 :ref:`INTERPOLATE_CUBIC<class_Image_constant_INTERPOLATE_CUBIC>`, mais le résultat est moins bon.
.. _class_Image_constant_INTERPOLATE_CUBIC:
.. rst-class:: classref-enumeration-constant
:ref:`Interpolation<enum_Image_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 :ref:`INTERPOLATE_BILINEAR<class_Image_constant_INTERPOLATE_BILINEAR>`, mais est plus lente.
.. _class_Image_constant_INTERPOLATE_TRILINEAR:
.. rst-class:: classref-enumeration-constant
:ref:`Interpolation<enum_Image_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 :ref:`INTERPOLATE_BILINEAR<class_Image_constant_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 :ref:`generate_mipmaps()<class_Image_method_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.
.. _class_Image_constant_INTERPOLATE_LANCZOS:
.. rst-class:: classref-enumeration-constant
:ref:`Interpolation<enum_Image_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.
.. rst-class:: classref-item-separator
----
.. _enum_Image_AlphaMode:
.. rst-class:: classref-enumeration
enum **AlphaMode**: :ref:`🔗<enum_Image_AlphaMode>`
.. _class_Image_constant_ALPHA_NONE:
.. rst-class:: classref-enumeration-constant
:ref:`AlphaMode<enum_Image_AlphaMode>` **ALPHA_NONE** = ``0``
L’image n’a pas d'opacité.
.. _class_Image_constant_ALPHA_BIT:
.. rst-class:: classref-enumeration-constant
:ref:`AlphaMode<enum_Image_AlphaMode>` **ALPHA_BIT** = ``1``
L'image stocke l'opacité sur un seul bit.
.. _class_Image_constant_ALPHA_BLEND:
.. rst-class:: classref-enumeration-constant
:ref:`AlphaMode<enum_Image_AlphaMode>` **ALPHA_BLEND** = ``2``
L'image utilise l'opacité.
.. rst-class:: classref-item-separator
----
.. _enum_Image_CompressMode:
.. rst-class:: classref-enumeration
enum **CompressMode**: :ref:`🔗<enum_Image_CompressMode>`
.. _class_Image_constant_COMPRESS_S3TC:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_S3TC** = ``0``
Utiliser la compression ST3TC.
.. _class_Image_constant_COMPRESS_ETC:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_ETC** = ``1``
Utiliser la compression ETC.
.. _class_Image_constant_COMPRESS_ETC2:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_ETC2** = ``2``
Utiliser la compression ETC2.
.. _class_Image_constant_COMPRESS_BPTC:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_BPTC** = ``3``
Utiliser la compression BPTC.
.. _class_Image_constant_COMPRESS_ASTC:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_ASTC** = ``4``
Utiliser la compression ASTC.
.. _class_Image_constant_COMPRESS_MAX:
.. rst-class:: classref-enumeration-constant
:ref:`CompressMode<enum_Image_CompressMode>` **COMPRESS_MAX** = ``5``
Représente la taille de l'énumération :ref:`CompressMode<enum_Image_CompressMode>`.
.. rst-class:: classref-item-separator
----
.. _enum_Image_UsedChannels:
.. rst-class:: classref-enumeration
enum **UsedChannels**: :ref:`🔗<enum_Image_UsedChannels>`
.. _class_Image_constant_USED_CHANNELS_L:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_L** = ``0``
L'image n'utilise qu'un canal pour la luminance (niveaux de gris).
.. _class_Image_constant_USED_CHANNELS_LA:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_LA** = ``1``
L'image utilise deux canaux pour la luminance et l'alpha, respectivement.
.. _class_Image_constant_USED_CHANNELS_R:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_R** = ``2``
L'image n'utilise que le canal rouge.
.. _class_Image_constant_USED_CHANNELS_RG:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_RG** = ``3``
L'image utilise deux canaux pour le rouge et le vert.
.. _class_Image_constant_USED_CHANNELS_RGB:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_RGB** = ``4``
L'image utilise trois canaux pour le rouge, le vert et le bleu.
.. _class_Image_constant_USED_CHANNELS_RGBA:
.. rst-class:: classref-enumeration-constant
:ref:`UsedChannels<enum_Image_UsedChannels>` **USED_CHANNELS_RGBA** = ``5``
L'image utilise quatre canaux pour le rouge, le vert, le bleu et l'alpha.
.. rst-class:: classref-item-separator
----
.. _enum_Image_CompressSource:
.. rst-class:: classref-enumeration
enum **CompressSource**: :ref:`🔗<enum_Image_CompressSource>`
.. _class_Image_constant_COMPRESS_SOURCE_GENERIC:
.. rst-class:: classref-enumeration-constant
:ref:`CompressSource<enum_Image_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.
.. _class_Image_constant_COMPRESS_SOURCE_SRGB:
.. rst-class:: classref-enumeration-constant
:ref:`CompressSource<enum_Image_CompressSource>` **COMPRESS_SOURCE_SRGB** = ``1``
La texture d'origine (avant la compression) est dans l'espace sRGB.
.. _class_Image_constant_COMPRESS_SOURCE_NORMAL:
.. rst-class:: classref-enumeration-constant
:ref:`CompressSource<enum_Image_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).
.. rst-class:: classref-item-separator
----
.. _enum_Image_ASTCFormat:
.. rst-class:: classref-enumeration
enum **ASTCFormat**: :ref:`🔗<enum_Image_ASTCFormat>`
.. _class_Image_constant_ASTC_FORMAT_4x4:
.. rst-class:: classref-enumeration-constant
:ref:`ASTCFormat<enum_Image_ASTCFormat>` **ASTC_FORMAT_4x4** = ``0``
Indice indiquant que le format de compression 4×4 ASTC haute qualité devrait être utilisé.
.. _class_Image_constant_ASTC_FORMAT_8x8:
.. rst-class:: classref-enumeration-constant
:ref:`ASTCFormat<enum_Image_ASTCFormat>` **ASTC_FORMAT_8x8** = ``1``
Indice indiquant que le format de compression 8×8 ASTC basse qualité devrait être utilisé.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Constantes
--------------------
.. _class_Image_constant_MAX_WIDTH:
.. rst-class:: classref-constant
**MAX_WIDTH** = ``16777216`` :ref:`🔗<class_Image_constant_MAX_WIDTH>`
La largeur maximale autorisée pour les **Image**.
.. _class_Image_constant_MAX_HEIGHT:
.. rst-class:: classref-constant
**MAX_HEIGHT** = ``16777216`` :ref:`🔗<class_Image_constant_MAX_HEIGHT>`
La hauteur maximale autorisée pour les **Image**.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des propriétés
------------------------------------------------------
.. _class_Image_property_data:
.. rst-class:: classref-property
:ref:`Dictionary<class_Dictionary>` **data** = ``{ "data": PackedByteArray(), "format": "Lum8", "height": 0, "mipmaps": false, "width": 0 }`` :ref:`🔗<class_Image_property_data>`
Garde tous les données de couleur de l'image dans un format donné. Voir les constantes :ref:`Format<enum_Image_Format>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_Image_method_adjust_bcs:
.. rst-class:: classref-method
|void| **adjust_bcs**\ (\ brightness\: :ref:`float<class_float>`, contrast\: :ref:`float<class_float>`, saturation\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Image_method_adjust_bcs>`
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 :ref:`is_compressed()<class_Image_method_is_compressed>`).
.. rst-class:: classref-item-separator
----
.. _class_Image_method_blend_rect:
.. rst-class:: classref-method
|void| **blend_rect**\ (\ src\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_Image_method_blend_rect>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_blend_rect_mask:
.. rst-class:: classref-method
|void| **blend_rect_mask**\ (\ src\: :ref:`Image<class_Image>`, mask\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_Image_method_blend_rect_mask>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_blit_rect:
.. rst-class:: classref-method
|void| **blit_rect**\ (\ src\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_Image_method_blit_rect>`
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 :ref:`blend_rect()<class_Image_method_blend_rect>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_blit_rect_mask:
.. rst-class:: classref-method
|void| **blit_rect_mask**\ (\ src\: :ref:`Image<class_Image>`, mask\: :ref:`Image<class_Image>`, src_rect\: :ref:`Rect2i<class_Rect2i>`, dst\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_Image_method_blit_rect_mask>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_bump_map_to_normal_map:
.. rst-class:: classref-method
|void| **bump_map_to_normal_map**\ (\ bump_scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_Image_method_bump_map_to_normal_map>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_clear_mipmaps:
.. rst-class:: classref-method
|void| **clear_mipmaps**\ (\ ) :ref:`🔗<class_Image_method_clear_mipmaps>`
Retire les mipmaps de l'image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_compress:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **compress**\ (\ mode\: :ref:`CompressMode<enum_Image_CompressMode>`, source\: :ref:`CompressSource<enum_Image_CompressSource>` = 0, astc_format\: :ref:`ASTCFormat<enum_Image_ASTCFormat>` = 0\ ) :ref:`🔗<class_Image_method_compress>`
Compresse l'image pour utiliser moins de mémoire. Impossible d'accéder directement aux données de pixels pendant que l'image est en cours de compression. Renvoie une erreur si le mode de compression choisi n'est pas disponible.
Le paramètre ``source`` permet de choisir la meilleure méthode de compression pour les formats DXT et ETC2. Il est ignoré pour la compression ASTC.
Pour la compression ASTC, le paramètre ``astc_format`` doit être fourni.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_compress_from_channels:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **compress_from_channels**\ (\ mode\: :ref:`CompressMode<enum_Image_CompressMode>`, channels\: :ref:`UsedChannels<enum_Image_UsedChannels>`, astc_format\: :ref:`ASTCFormat<enum_Image_ASTCFormat>` = 0\ ) :ref:`🔗<class_Image_method_compress_from_channels>`
Compresse l'image pour utiliser moins de mémoire. Impossible d'accéder directement aux données de pixels pendant que l'image est en cours de compression. Renvoie une erreur si le mode de compression choisi n'est pas disponible.
Il s'agit d'une alternative à :ref:`compress()<class_Image_method_compress>` qui laisse l'utilisateur fournir les canaux utilisés pour que le compresseur choisisse le meilleur format entre DXT et ETC2. Pour les autres formats (non DXT ou ETC2), l'argument est ignoré.
Pour la compression ASTC, le paramètre ``astc_format`` doit être fourni.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_compute_image_metrics:
.. rst-class:: classref-method
:ref:`Dictionary<class_Dictionary>` **compute_image_metrics**\ (\ compared_image\: :ref:`Image<class_Image>`, use_luma\: :ref:`bool<class_bool>`\ ) :ref:`🔗<class_Image_method_compute_image_metrics>`
Calcule les métriques d'image sur l'image actuelle et l'image comparée.
Le dictionnaire contient ``max``, ``mean``, ``mean_squared``, ``root_mean_squared`` et ``peak_snr``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_convert:
.. rst-class:: classref-method
|void| **convert**\ (\ format\: :ref:`Format<enum_Image_Format>`\ ) :ref:`🔗<class_Image_method_convert>`
Convertit le format de cette image au format ``format`` donné.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_copy_from:
.. rst-class:: classref-method
|void| **copy_from**\ (\ src\: :ref:`Image<class_Image>`\ ) :ref:`🔗<class_Image_method_copy_from>`
Copie l'image ``src`` vers cette image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_create:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **create**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`\ ) |static| :ref:`🔗<class_Image_method_create>`
**Obsolète :** Use :ref:`create_empty()<class_Image_method_create_empty>`.
Crée une image vide de la taille et du format donnés. Si ``use_mipmaps`` vaut ``true``, génère des mipmaps pour cette image. Voir :ref:`generate_mipmaps()<class_Image_method_generate_mipmaps>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_create_empty:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **create_empty**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`\ ) |static| :ref:`🔗<class_Image_method_create_empty>`
Crée une image vide de la taille et du format donnés. Si ``use_mipmaps`` vaut ``true``, génère des mipmaps pour cette image. Voir :ref:`generate_mipmaps()<class_Image_method_generate_mipmaps>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_create_from_data:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **create_from_data**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |static| :ref:`🔗<class_Image_method_create_from_data>`
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 :ref:`generate_mipmaps()<class_Image_method_generate_mipmaps>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_crop:
.. rst-class:: classref-method
|void| **crop**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Image_method_crop>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_decompress:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **decompress**\ (\ ) :ref:`🔗<class_Image_method_decompress>`
Décompresse l'image si elle est compressée en VRAM en un format supporté. Renvoie :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` si le format est supporté, sinon :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>`.
\ **Note :** Les formats suivants peuvent être décompressés : DXT, RGTC, BPTC. Les formats ETC1 et ETC2 ne sont pas pris en charge.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_detect_alpha:
.. rst-class:: classref-method
:ref:`AlphaMode<enum_Image_AlphaMode>` **detect_alpha**\ (\ ) |const| :ref:`🔗<class_Image_method_detect_alpha>`
Renvoie :ref:`ALPHA_BLEND<class_Image_constant_ALPHA_BLEND>` si l’image a des données pour les valeurs alpha. Renvoie :ref:`ALPHA_BIT<class_Image_constant_ALPHA_BIT>` si toutes les valeurs alpha sont stockées en un seul bit. Renvoie :ref:`ALPHA_NONE<class_Image_constant_ALPHA_NONE>` si aucune donnée pour les valeurs alpha n’est trouvée.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_detect_used_channels:
.. rst-class:: classref-method
:ref:`UsedChannels<enum_Image_UsedChannels>` **detect_used_channels**\ (\ source\: :ref:`CompressSource<enum_Image_CompressSource>` = 0\ ) |const| :ref:`🔗<class_Image_method_detect_used_channels>`
Renvoie les canaux de couleur utilisés par cette image. Si l'image est compressée, la ``source`` originelle doit être spécifiée.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_fill:
.. rst-class:: classref-method
|void| **fill**\ (\ color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Image_method_fill>`
Remplit toute l'image avec la couleur ``color``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_fill_rect:
.. rst-class:: classref-method
|void| **fill_rect**\ (\ rect\: :ref:`Rect2i<class_Rect2i>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Image_method_fill_rect>`
Remplit le ``rect`` avec la ``color``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_fix_alpha_edges:
.. rst-class:: classref-method
|void| **fix_alpha_edges**\ (\ ) :ref:`🔗<class_Image_method_fix_alpha_edges>`
Mélange les pixels à faible opacité (alpha) avec ceux proches.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_flip_x:
.. rst-class:: classref-method
|void| **flip_x**\ (\ ) :ref:`🔗<class_Image_method_flip_x>`
Inverse l'image horizontalement.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_flip_y:
.. rst-class:: classref-method
|void| **flip_y**\ (\ ) :ref:`🔗<class_Image_method_flip_y>`
Inverse l'image verticalement.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_generate_mipmaps:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **generate_mipmaps**\ (\ renormalize\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_Image_method_generate_mipmaps>`
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 :ref:`has_mipmaps()<class_Image_method_has_mipmaps>` ou :ref:`get_mipmap_count()<class_Image_method_get_mipmap_count>`. Appeler :ref:`generate_mipmaps()<class_Image_method_generate_mipmaps>` sur une image qui a déjà des mipmaps remplacera les mipmaps existantes dans l'image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_data:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **get_data**\ (\ ) |const| :ref:`🔗<class_Image_method_get_data>`
Renvoie une copie des données brutes de l’image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_data_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_data_size**\ (\ ) |const| :ref:`🔗<class_Image_method_get_data_size>`
Renvoie la taille (en octets) des données brutes de l'image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_format:
.. rst-class:: classref-method
:ref:`Format<enum_Image_Format>` **get_format**\ (\ ) |const| :ref:`🔗<class_Image_method_get_format>`
Renvoie le format de cette image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_height:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_height**\ (\ ) |const| :ref:`🔗<class_Image_method_get_height>`
Renvoie la hauteur de l'image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_mipmap_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_mipmap_count**\ (\ ) |const| :ref:`🔗<class_Image_method_get_mipmap_count>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_mipmap_offset:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_mipmap_offset**\ (\ mipmap\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Image_method_get_mipmap_offset>`
Renvoie le décalage où la mipmap de l'image avec l'index ``mipmap`` est stockée dans le dictionnaire :ref:`data<class_Image_property_data>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_pixel:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **get_pixel**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Image_method_get_pixel>`
Renvoie la couleur du pixel à ``(x, y)``.
C'est la même chose que :ref:`get_pixelv()<class_Image_method_get_pixelv>`, mais avec deux arguments entiers au lieu d'un argument :ref:`Vector2i<class_Vector2i>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_pixelv:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **get_pixelv**\ (\ point\: :ref:`Vector2i<class_Vector2i>`\ ) |const| :ref:`🔗<class_Image_method_get_pixelv>`
Renvoie la couleur du pixel au ``point`` donné.
C'est la même chose que :ref:`get_pixel()<class_Image_method_get_pixel>`, mais avec un argument :ref:`Vector2i<class_Vector2i>` au lieu de deux arguments entiers.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_region:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **get_region**\ (\ region\: :ref:`Rect2i<class_Rect2i>`\ ) |const| :ref:`🔗<class_Image_method_get_region>`
Renvoie une nouvelle **Image** qui est une copie de la zone de cette **Image** spécifiée par ``region``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_size:
.. rst-class:: classref-method
:ref:`Vector2i<class_Vector2i>` **get_size**\ (\ ) |const| :ref:`🔗<class_Image_method_get_size>`
Renvoie la taille de l'image (la largeur et la hauteur).
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_used_rect:
.. rst-class:: classref-method
:ref:`Rect2i<class_Rect2i>` **get_used_rect**\ (\ ) |const| :ref:`🔗<class_Image_method_get_used_rect>`
Renvoie un :ref:`Rect2i<class_Rect2i>` contenant la partie visible de l'image, en considérant chaque pixel avec un canal alpha non nul comme visible.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_get_width:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_width**\ (\ ) |const| :ref:`🔗<class_Image_method_get_width>`
Renvoie la largeur de l'image.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_has_mipmaps:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_mipmaps**\ (\ ) |const| :ref:`🔗<class_Image_method_has_mipmaps>`
Renvoie ``true`` si l'image a des mipmaps générées.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_is_compressed:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_compressed**\ (\ ) |const| :ref:`🔗<class_Image_method_is_compressed>`
Renvoie ``true`` si l'image est compressée.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_Image_method_is_empty>`
Renvoie ``true`` si l'image n'a aucune données.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_is_invisible:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_invisible**\ (\ ) |const| :ref:`🔗<class_Image_method_is_invisible>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_linear_to_srgb:
.. rst-class:: classref-method
|void| **linear_to_srgb**\ (\ ) :ref:`🔗<class_Image_method_linear_to_srgb>`
Convertit l'image entière de l'espace de couleur linéaire à l'espace de couleur sRGB. Fonctionne seulement sur des images en format :ref:`FORMAT_RGB8<class_Image_constant_FORMAT_RGB8>` ou :ref:`FORMAT_RGBA8<class_Image_constant_FORMAT_RGBA8>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load**\ (\ path\: :ref:`String<class_String>`\ ) :ref:`🔗<class_Image_method_load>`
Charge une image depuis le fichier ``path``. Voir `Formats d'image pris en charge <../tutorials/assets_pipeline/importing_images.html#supported-image-formats>`__ 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 :ref:`ImageTexture<class_ImageTexture>` pour des exemples d'utilisation.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_bmp_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_bmp_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_bmp_from_buffer>`
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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_dds_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_dds_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_dds_from_buffer>`
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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_from_file:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **load_from_file**\ (\ path\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_Image_method_load_from_file>`
Crée une nouvelle **Image** et charge les données depuis le fichier spécifié.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_jpg_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_jpg_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_jpg_from_buffer>`
Charge une image à partir du contenu binaire d’un fichier JPEG.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_ktx_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_ktx_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_ktx_from_buffer>`
Charge une image du contenu binaire d'un fichier `KTX <https://github.com/KhronosGroup/KTX-Software>`__. 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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_png_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_png_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_png_from_buffer>`
Charge une image à partir du contenu binaire d'un fichier PNG.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_svg_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_svg_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`, scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_Image_method_load_svg_from_buffer>`
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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_svg_from_string:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_svg_from_string**\ (\ svg_str\: :ref:`String<class_String>`, scale\: :ref:`float<class_float>` = 1.0\ ) :ref:`🔗<class_Image_method_load_svg_from_string>`
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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_tga_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_tga_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_tga_from_buffer>`
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``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_load_webp_from_buffer:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **load_webp_from_buffer**\ (\ buffer\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_load_webp_from_buffer>`
Charge une image depuis le contenu binaire d'un fichier WebP.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_normal_map_to_xy:
.. rst-class:: classref-method
|void| **normal_map_to_xy**\ (\ ) :ref:`🔗<class_Image_method_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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_premultiply_alpha:
.. rst-class:: classref-method
|void| **premultiply_alpha**\ (\ ) :ref:`🔗<class_Image_method_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 :ref:`CanvasItemMaterial.blend_mode<class_CanvasItemMaterial_property_blend_mode>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_resize:
.. rst-class:: classref-method
|void| **resize**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, interpolation\: :ref:`Interpolation<enum_Image_Interpolation>` = 1\ ) :ref:`🔗<class_Image_method_resize>`
Redimensionne l'image à la largeur ``width`` et hauteur ``height`` données. Les nouveaux pixels sont calculés à l'aide du mode d'``interpolation`` défini via les constantes :ref:`Interpolation<enum_Image_Interpolation>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_resize_to_po2:
.. rst-class:: classref-method
|void| **resize_to_po2**\ (\ square\: :ref:`bool<class_bool>` = false, interpolation\: :ref:`Interpolation<enum_Image_Interpolation>` = 1\ ) :ref:`🔗<class_Image_method_resize_to_po2>`
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 :ref:`Interpolation<enum_Image_Interpolation>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_rgbe_to_srgb:
.. rst-class:: classref-method
:ref:`Image<class_Image>` **rgbe_to_srgb**\ (\ ) :ref:`🔗<class_Image_method_rgbe_to_srgb>`
Convertit une image RGBE (« Red Green Blue Exponent ») standard en image sRGB.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_rotate_90:
.. rst-class:: classref-method
|void| **rotate_90**\ (\ direction\: :ref:`ClockDirection<enum_@GlobalScope_ClockDirection>`\ ) :ref:`🔗<class_Image_method_rotate_90>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_rotate_180:
.. rst-class:: classref-method
|void| **rotate_180**\ (\ ) :ref:`🔗<class_Image_method_rotate_180>`
Pivote l'image de ``180`` degrés. La largeur et la hauteur de l'image doivent être supérieures à ``1``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_dds:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **save_dds**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_Image_method_save_dds>`
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 :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_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 :ref:`save_dds()<class_Image_method_save_dds>` renverra :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` lorsqu'elle est appelée à partir d'un projet exporté.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_dds_to_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **save_dds_to_buffer**\ (\ ) |const| :ref:`🔗<class_Image_method_save_dds_to_buffer>`
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 :ref:`save_dds_to_buffer()<class_Image_method_save_dds_to_buffer>` renverra un tableau d'octets vide lorsqu'elle est appelée à partir d'un projet exporté.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_exr:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **save_exr**\ (\ path\: :ref:`String<class_String>`, grayscale\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Image_method_save_exr>`
Sauvegarde l'image comme un fichier EXR au chemin ``path``. Si ``grayscale`` vaut ``true`` et que l'image n'a qu'un seul canal, elle sera enregistrée explicitement comme monochrome plutôt qu'un seul canal rouge. Cette fonction renverra :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` si Godot a été compilé sans le module TinyEXR.
\ **Note :** Le module TinyEXR est désactivé dans les compilations non-éditeur, ce qui signifie que :ref:`save_exr()<class_Image_method_save_exr>` renverra :ref:`@GlobalScope.ERR_UNAVAILABLE<class_@GlobalScope_constant_ERR_UNAVAILABLE>` lorsqu'elle est appelée à partir d'un projet exporté.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_exr_to_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **save_exr_to_buffer**\ (\ grayscale\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Image_method_save_exr_to_buffer>`
Sauvegarde l'image comme un fichier EXR en un tableau d'octets. Si ``grayscale`` vaut ``true`` et que l'image n'a qu'un seul canal, elle sera enregistrée explicitement comme monochrome plutôt qu'un seul canal rouge.Cette fonction renverra un tableau d'octets vide si Godot a été compilé sans le module TinyEXR.
\ **Note :** Le module TinyEXR est désactivé dans les compilations non-éditeur, ce qui signifie que :ref:`save_exr_to_buffer()<class_Image_method_save_exr_to_buffer>` renverra un tableau d'octets vide lorsqu'elle est appelée à partir d'un projet exporté.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_jpg:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **save_jpg**\ (\ path\: :ref:`String<class_String>`, quality\: :ref:`float<class_float>` = 0.75\ ) |const| :ref:`🔗<class_Image_method_save_jpg>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_jpg_to_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **save_jpg_to_buffer**\ (\ quality\: :ref:`float<class_float>` = 0.75\ ) |const| :ref:`🔗<class_Image_method_save_jpg_to_buffer>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_png:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **save_png**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_Image_method_save_png>`
Enregistre l'image en un fichier PNG à l'emplacement ``path``.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_png_to_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **save_png_to_buffer**\ (\ ) |const| :ref:`🔗<class_Image_method_save_png_to_buffer>`
Enregistre l'image comme un fichier PNG vers un tableau d'octets.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_webp:
.. rst-class:: classref-method
:ref:`Error<enum_@GlobalScope_Error>` **save_webp**\ (\ path\: :ref:`String<class_String>`, lossy\: :ref:`bool<class_bool>` = false, quality\: :ref:`float<class_float>` = 0.75\ ) |const| :ref:`🔗<class_Image_method_save_webp>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_save_webp_to_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **save_webp_to_buffer**\ (\ lossy\: :ref:`bool<class_bool>` = false, quality\: :ref:`float<class_float>` = 0.75\ ) |const| :ref:`🔗<class_Image_method_save_webp_to_buffer>`
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.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_set_data:
.. rst-class:: classref-method
|void| **set_data**\ (\ width\: :ref:`int<class_int>`, height\: :ref:`int<class_int>`, use_mipmaps\: :ref:`bool<class_bool>`, format\: :ref:`Format<enum_Image_Format>`, data\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_Image_method_set_data>`
Écrase les données d'une **Image** existante. Équivalent non statique de :ref:`create_from_data()<class_Image_method_create_from_data>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_set_pixel:
.. rst-class:: classref-method
|void| **set_pixel**\ (\ x\: :ref:`int<class_int>`, y\: :ref:`int<class_int>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Image_method_set_pixel>`
Définit la :ref:`Color<class_Color>` du pixel à ``(x, y)`` à ``color``.
.. tabs::
.. code-tab:: gdscript
var largeur_img = 10
var hauteur_img = 5
var img = Image.create(largeur_img, hauteur_img, false, Image.FORMAT_RGBA8)
img.set_pixel(1, 2, Color.RED) # Définit la couleur en (1,2) en rouge.
.. code-tab:: csharp
int largeurImage = 10;
int hauteurImage = 5;
var img = Image.Create(largeurImage, hauteurImage, false, Image.Format.Rgba8);
img.SetPixel(1, 2, Colors.Red); // Définit la couleur en (1,2) en rouge.
Identique à :ref:`set_pixelv()<class_Image_method_set_pixelv>`, mais avec deux arguments entiers au lieu d'un argument :ref:`Vector2i<class_Vector2i>`.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_set_pixelv:
.. rst-class:: classref-method
|void| **set_pixelv**\ (\ point\: :ref:`Vector2i<class_Vector2i>`, color\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Image_method_set_pixelv>`
Définit la :ref:`Color<class_Color>` du pixel au point ``point`` à ``color``.
.. tabs::
.. code-tab:: gdscript
var largeur_img = 10
var hauteur_img = 5
var img = Image.create(largeur_img, hauteur_img, false, Image.FORMAT_RGBA8)
img.set_pixelv(Vector2i(1, 2), Color.RED) # Définit la couleur en (1,2) en rouge.
.. code-tab:: csharp
int largeurImage = 10;
int hauteurImage = 5;
var img = Image.Create(largeurImage, hauteurImage, false, Image.Format.Rgba8);
img.SetPixelv(new Vector2I(1, 2), Colors.Red); // Définit la couleur en (1,2) en rouge.
Identique à :ref:`set_pixel()<class_Image_method_set_pixel>`, mais avec un argument en :ref:`Vector2i<class_Vector2i>` au lieu de deux arguments entiers.
.. rst-class:: classref-item-separator
----
.. _class_Image_method_shrink_x2:
.. rst-class:: classref-method
|void| **shrink_x2**\ (\ ) :ref:`🔗<class_Image_method_shrink_x2>`
Rétrécit l'image par un facteur 2 sur chaque axe (ceci divise le nombre de pixels par 4).
.. rst-class:: classref-item-separator
----
.. _class_Image_method_srgb_to_linear:
.. rst-class:: classref-method
|void| **srgb_to_linear**\ (\ ) :ref:`🔗<class_Image_method_srgb_to_linear>`
Convertit des données brutes depuis l'espace de couleur sRGB vers une échelle linéaire. Ne fonctionne que sur des images en formats :ref:`FORMAT_RGB8<class_Image_constant_FORMAT_RGB8>` ou :ref:`FORMAT_RGBA8<class_Image_constant_FORMAT_RGBA8>`.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink