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.x
godot-docs-l10n/classes/it/class_color.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

2468 lines
86 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_Color:
Color
=====
Un colore rappresentato in formato RGBA.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
A color represented in RGBA format by a red (:ref:`r<class_Color_property_r>`), green (:ref:`g<class_Color_property_g>`), blue (:ref:`b<class_Color_property_b>`), and alpha (:ref:`a<class_Color_property_a>`) component. Each component is a 32-bit floating-point value, usually ranging from ``0.0`` to ``1.0``. Some properties (such as :ref:`CanvasItem.modulate<class_CanvasItem_property_modulate>`) may support values greater than ``1.0``, for overbright or HDR (High Dynamic Range) colors.
Colors can be created in a number of ways: By the various **Color** constructors, by static methods such as :ref:`from_hsv()<class_Color_method_from_hsv>`, and by using a name from the set of standardized colors based on `X11 color names <https://en.wikipedia.org/wiki/X11_color_names>`__ with the addition of :ref:`TRANSPARENT<class_Color_constant_TRANSPARENT>`.
\ `Color constants cheatsheet <https://raw.githubusercontent.com/godotengine/godot-docs/master/img/color_constants.png>`__\
Although **Color** may be used to store values of any encoding, the red (:ref:`r<class_Color_property_r>`), green (:ref:`g<class_Color_property_g>`), and blue (:ref:`b<class_Color_property_b>`) properties of **Color** are expected by Godot to be encoded using the `nonlinear sRGB transfer function <https://en.wikipedia.org/wiki/SRGB#Transfer_function_(%22gamma%22)>`__ unless otherwise stated. This color encoding is used by many traditional art and web tools, making it easy to match colors between Godot and these tools. Godot uses `Rec. ITU-R BT.709 <https://en.wikipedia.org/wiki/Rec._709>`__ color primaries, which are used by the sRGB standard.
All physical simulation, such as lighting calculations, and colorimetry transformations, such as :ref:`get_luminance()<class_Color_method_get_luminance>`, must be performed on linearly encoded values to produce correct results. When performing these calculations, convert **Color** to and from linear encoding using :ref:`srgb_to_linear()<class_Color_method_srgb_to_linear>` and :ref:`linear_to_srgb()<class_Color_method_linear_to_srgb>`.
\ **Note:** In a boolean context, a Color will evaluate to ``false`` if it is equal to ``Color(0, 0, 0, 1)`` (opaque black). Otherwise, a Color will always evaluate to ``true``.
.. note::
Ci sono differenze sostanziali quando si usa questa API con C#. Vedi :ref:`doc_c_sharp_differences` per maggiori informazioni.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- `Demo di GD Paint 2D <https://godotengine.org/asset-library/asset/2768>`__
- `Demo di interpolazione Tween <https://godotengine.org/asset-library/asset/2733>`__
- `Demo di trascinamento e rilascio in un interfaccia utente <https://godotengine.org/asset-library/asset/2767>`__
.. rst-class:: classref-reftable-group
Proprietà
------------------
.. table::
:widths: auto
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`a<class_Color_property_a>` | ``1.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`int<class_int>` | :ref:`a8<class_Color_property_a8>` | ``255`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`b<class_Color_property_b>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`int<class_int>` | :ref:`b8<class_Color_property_b8>` | ``0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`g<class_Color_property_g>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`int<class_int>` | :ref:`g8<class_Color_property_g8>` | ``0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`h<class_Color_property_h>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`ok_hsl_h<class_Color_property_ok_hsl_h>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`ok_hsl_l<class_Color_property_ok_hsl_l>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`ok_hsl_s<class_Color_property_ok_hsl_s>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`r<class_Color_property_r>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`int<class_int>` | :ref:`r8<class_Color_property_r8>` | ``0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`s<class_Color_property_s>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
| :ref:`float<class_float>` | :ref:`v<class_Color_property_v>` | ``0.0`` |
+---------------------------+------------------------------------------------+---------+
.. rst-class:: classref-reftable-group
Costruttori
----------------------
.. table::
:widths: auto
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ from\: :ref:`Color<class_Color>`, alpha\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ from\: :ref:`Color<class_Color>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ code\: :ref:`String<class_String>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ code\: :ref:`String<class_String>`, alpha\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ r\: :ref:`float<class_float>`, g\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`Color<class_Color_constructor_Color>`\ (\ r\: :ref:`float<class_float>`, g\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`, a\: :ref:`float<class_float>`\ ) |
+---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`blend<class_Color_method_blend>`\ (\ over\: :ref:`Color<class_Color>`\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`clamp<class_Color_method_clamp>`\ (\ min\: :ref:`Color<class_Color>` = Color(0, 0, 0, 0), max\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`darkened<class_Color_method_darkened>`\ (\ amount\: :ref:`float<class_float>`\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`from_hsv<class_Color_method_from_hsv>`\ (\ h\: :ref:`float<class_float>`, s\: :ref:`float<class_float>`, v\: :ref:`float<class_float>`, alpha\: :ref:`float<class_float>` = 1.0\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`from_ok_hsl<class_Color_method_from_ok_hsl>`\ (\ h\: :ref:`float<class_float>`, s\: :ref:`float<class_float>`, l\: :ref:`float<class_float>`, alpha\: :ref:`float<class_float>` = 1.0\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`from_rgba8<class_Color_method_from_rgba8>`\ (\ r8\: :ref:`int<class_int>`, g8\: :ref:`int<class_int>`, b8\: :ref:`int<class_int>`, a8\: :ref:`int<class_int>` = 255\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`from_rgbe9995<class_Color_method_from_rgbe9995>`\ (\ rgbe\: :ref:`int<class_int>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`from_string<class_Color_method_from_string>`\ (\ str\: :ref:`String<class_String>`, default\: :ref:`Color<class_Color>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`get_luminance<class_Color_method_get_luminance>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`hex<class_Color_method_hex>`\ (\ hex\: :ref:`int<class_int>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`hex64<class_Color_method_hex64>`\ (\ hex\: :ref:`int<class_int>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`html<class_Color_method_html>`\ (\ rgba\: :ref:`String<class_String>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`html_is_valid<class_Color_method_html_is_valid>`\ (\ color\: :ref:`String<class_String>`\ ) |static| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`inverted<class_Color_method_inverted>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_equal_approx<class_Color_method_is_equal_approx>`\ (\ to\: :ref:`Color<class_Color>`\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`lerp<class_Color_method_lerp>`\ (\ to\: :ref:`Color<class_Color>`, weight\: :ref:`float<class_float>`\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`lightened<class_Color_method_lightened>`\ (\ amount\: :ref:`float<class_float>`\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`linear_to_srgb<class_Color_method_linear_to_srgb>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`srgb_to_linear<class_Color_method_srgb_to_linear>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_abgr32<class_Color_method_to_abgr32>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_abgr64<class_Color_method_to_abgr64>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_argb32<class_Color_method_to_argb32>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_argb64<class_Color_method_to_argb64>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_html<class_Color_method_to_html>`\ (\ with_alpha\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_rgba32<class_Color_method_to_rgba32>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_rgba64<class_Color_method_to_rgba64>`\ (\ ) |const| |
+-----------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operatori
------------------
.. table::
:widths: auto
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_Color_operator_neq_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator *<class_Color_operator_mul_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator *<class_Color_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator *<class_Color_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator +<class_Color_operator_sum_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator -<class_Color_operator_dif_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator /<class_Color_operator_div_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator /<class_Color_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator /<class_Color_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_Color_operator_eq_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator []<class_Color_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator unary+<class_Color_operator_unplus>`\ (\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator unary-<class_Color_operator_unminus>`\ (\ ) |
+---------------------------+---------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Costanti
----------------
.. _class_Color_constant_ALICE_BLUE:
.. rst-class:: classref-constant
**ALICE_BLUE** = ``Color(0.9411765, 0.972549, 1, 1)`` :ref:`🔗<class_Color_constant_ALICE_BLUE>`
Colore blu alice.
.. _class_Color_constant_ANTIQUE_WHITE:
.. rst-class:: classref-constant
**ANTIQUE_WHITE** = ``Color(0.98039216, 0.92156863, 0.84313726, 1)`` :ref:`🔗<class_Color_constant_ANTIQUE_WHITE>`
Colore bianco antico.
.. _class_Color_constant_AQUA:
.. rst-class:: classref-constant
**AQUA** = ``Color(0, 1, 1, 1)`` :ref:`🔗<class_Color_constant_AQUA>`
Colore acqua.
.. _class_Color_constant_AQUAMARINE:
.. rst-class:: classref-constant
**AQUAMARINE** = ``Color(0.49803922, 1, 0.83137256, 1)`` :ref:`🔗<class_Color_constant_AQUAMARINE>`
Colore acquamarina.
.. _class_Color_constant_AZURE:
.. rst-class:: classref-constant
**AZURE** = ``Color(0.9411765, 1, 1, 1)`` :ref:`🔗<class_Color_constant_AZURE>`
Colore azzurro.
.. _class_Color_constant_BEIGE:
.. rst-class:: classref-constant
**BEIGE** = ``Color(0.9607843, 0.9607843, 0.8627451, 1)`` :ref:`🔗<class_Color_constant_BEIGE>`
Colore beige.
.. _class_Color_constant_BISQUE:
.. rst-class:: classref-constant
**BISQUE** = ``Color(1, 0.89411765, 0.76862746, 1)`` :ref:`🔗<class_Color_constant_BISQUE>`
Colore biscotto.
.. _class_Color_constant_BLACK:
.. rst-class:: classref-constant
**BLACK** = ``Color(0, 0, 0, 1)`` :ref:`🔗<class_Color_constant_BLACK>`
Colore nero. In GDScript, questo è il valore predefinito di qualsiasi colore.
.. _class_Color_constant_BLANCHED_ALMOND:
.. rst-class:: classref-constant
**BLANCHED_ALMOND** = ``Color(1, 0.92156863, 0.8039216, 1)`` :ref:`🔗<class_Color_constant_BLANCHED_ALMOND>`
Colore bianco mandorla.
.. _class_Color_constant_BLUE:
.. rst-class:: classref-constant
**BLUE** = ``Color(0, 0, 1, 1)`` :ref:`🔗<class_Color_constant_BLUE>`
Colore blu.
.. _class_Color_constant_BLUE_VIOLET:
.. rst-class:: classref-constant
**BLUE_VIOLET** = ``Color(0.5411765, 0.16862746, 0.8862745, 1)`` :ref:`🔗<class_Color_constant_BLUE_VIOLET>`
Colore blu-violetto.
.. _class_Color_constant_BROWN:
.. rst-class:: classref-constant
**BROWN** = ``Color(0.64705884, 0.16470589, 0.16470589, 1)`` :ref:`🔗<class_Color_constant_BROWN>`
Colore marrone.
.. _class_Color_constant_BURLYWOOD:
.. rst-class:: classref-constant
**BURLYWOOD** = ``Color(0.87058824, 0.72156864, 0.5294118, 1)`` :ref:`🔗<class_Color_constant_BURLYWOOD>`
Colore burlywood.
.. _class_Color_constant_CADET_BLUE:
.. rst-class:: classref-constant
**CADET_BLUE** = ``Color(0.37254903, 0.61960787, 0.627451, 1)`` :ref:`🔗<class_Color_constant_CADET_BLUE>`
Colore blu cadetto.
.. _class_Color_constant_CHARTREUSE:
.. rst-class:: classref-constant
**CHARTREUSE** = ``Color(0.49803922, 1, 0, 1)`` :ref:`🔗<class_Color_constant_CHARTREUSE>`
Colore chartreuse.
.. _class_Color_constant_CHOCOLATE:
.. rst-class:: classref-constant
**CHOCOLATE** = ``Color(0.8235294, 0.4117647, 0.11764706, 1)`` :ref:`🔗<class_Color_constant_CHOCOLATE>`
Colore cioccolato.
.. _class_Color_constant_CORAL:
.. rst-class:: classref-constant
**CORAL** = ``Color(1, 0.49803922, 0.3137255, 1)`` :ref:`🔗<class_Color_constant_CORAL>`
Colore corallo.
.. _class_Color_constant_CORNFLOWER_BLUE:
.. rst-class:: classref-constant
**CORNFLOWER_BLUE** = ``Color(0.39215687, 0.58431375, 0.92941177, 1)`` :ref:`🔗<class_Color_constant_CORNFLOWER_BLUE>`
Colore blu fiordaliso.
.. _class_Color_constant_CORNSILK:
.. rst-class:: classref-constant
**CORNSILK** = ``Color(1, 0.972549, 0.8627451, 1)`` :ref:`🔗<class_Color_constant_CORNSILK>`
Colore seta di mais.
.. _class_Color_constant_CRIMSON:
.. rst-class:: classref-constant
**CRIMSON** = ``Color(0.8627451, 0.078431375, 0.23529412, 1)`` :ref:`🔗<class_Color_constant_CRIMSON>`
Colore cremisi.
.. _class_Color_constant_CYAN:
.. rst-class:: classref-constant
**CYAN** = ``Color(0, 1, 1, 1)`` :ref:`🔗<class_Color_constant_CYAN>`
Colore ciano.
.. _class_Color_constant_DARK_BLUE:
.. rst-class:: classref-constant
**DARK_BLUE** = ``Color(0, 0, 0.54509807, 1)`` :ref:`🔗<class_Color_constant_DARK_BLUE>`
Colore blu scuro.
.. _class_Color_constant_DARK_CYAN:
.. rst-class:: classref-constant
**DARK_CYAN** = ``Color(0, 0.54509807, 0.54509807, 1)`` :ref:`🔗<class_Color_constant_DARK_CYAN>`
Colore ciano scuro.
.. _class_Color_constant_DARK_GOLDENROD:
.. rst-class:: classref-constant
**DARK_GOLDENROD** = ``Color(0.72156864, 0.5254902, 0.043137256, 1)`` :ref:`🔗<class_Color_constant_DARK_GOLDENROD>`
Colore verga d'oro scuro.
.. _class_Color_constant_DARK_GRAY:
.. rst-class:: classref-constant
**DARK_GRAY** = ``Color(0.6627451, 0.6627451, 0.6627451, 1)`` :ref:`🔗<class_Color_constant_DARK_GRAY>`
Colore grigio scuro.
.. _class_Color_constant_DARK_GREEN:
.. rst-class:: classref-constant
**DARK_GREEN** = ``Color(0, 0.39215687, 0, 1)`` :ref:`🔗<class_Color_constant_DARK_GREEN>`
Colore verde scuro.
.. _class_Color_constant_DARK_KHAKI:
.. rst-class:: classref-constant
**DARK_KHAKI** = ``Color(0.7411765, 0.7176471, 0.41960785, 1)`` :ref:`🔗<class_Color_constant_DARK_KHAKI>`
Colore cachi scuro.
.. _class_Color_constant_DARK_MAGENTA:
.. rst-class:: classref-constant
**DARK_MAGENTA** = ``Color(0.54509807, 0, 0.54509807, 1)`` :ref:`🔗<class_Color_constant_DARK_MAGENTA>`
Colore magenta scuro.
.. _class_Color_constant_DARK_OLIVE_GREEN:
.. rst-class:: classref-constant
**DARK_OLIVE_GREEN** = ``Color(0.33333334, 0.41960785, 0.18431373, 1)`` :ref:`🔗<class_Color_constant_DARK_OLIVE_GREEN>`
Colore verde oliva scuro.
.. _class_Color_constant_DARK_ORANGE:
.. rst-class:: classref-constant
**DARK_ORANGE** = ``Color(1, 0.54901963, 0, 1)`` :ref:`🔗<class_Color_constant_DARK_ORANGE>`
Colore arancione scuro.
.. _class_Color_constant_DARK_ORCHID:
.. rst-class:: classref-constant
**DARK_ORCHID** = ``Color(0.6, 0.19607843, 0.8, 1)`` :ref:`🔗<class_Color_constant_DARK_ORCHID>`
Colore orchidea scuro.
.. _class_Color_constant_DARK_RED:
.. rst-class:: classref-constant
**DARK_RED** = ``Color(0.54509807, 0, 0, 1)`` :ref:`🔗<class_Color_constant_DARK_RED>`
Colore rosso scuro.
.. _class_Color_constant_DARK_SALMON:
.. rst-class:: classref-constant
**DARK_SALMON** = ``Color(0.9137255, 0.5882353, 0.47843137, 1)`` :ref:`🔗<class_Color_constant_DARK_SALMON>`
Colore salmone scuro.
.. _class_Color_constant_DARK_SEA_GREEN:
.. rst-class:: classref-constant
**DARK_SEA_GREEN** = ``Color(0.56078434, 0.7372549, 0.56078434, 1)`` :ref:`🔗<class_Color_constant_DARK_SEA_GREEN>`
Colore verde mare scuro.
.. _class_Color_constant_DARK_SLATE_BLUE:
.. rst-class:: classref-constant
**DARK_SLATE_BLUE** = ``Color(0.28235295, 0.23921569, 0.54509807, 1)`` :ref:`🔗<class_Color_constant_DARK_SLATE_BLUE>`
Colore blu ardesia scuro.
.. _class_Color_constant_DARK_SLATE_GRAY:
.. rst-class:: classref-constant
**DARK_SLATE_GRAY** = ``Color(0.18431373, 0.30980393, 0.30980393, 1)`` :ref:`🔗<class_Color_constant_DARK_SLATE_GRAY>`
Colore grigio ardesia scuro.
.. _class_Color_constant_DARK_TURQUOISE:
.. rst-class:: classref-constant
**DARK_TURQUOISE** = ``Color(0, 0.80784315, 0.81960785, 1)`` :ref:`🔗<class_Color_constant_DARK_TURQUOISE>`
Colore turchese scuro.
.. _class_Color_constant_DARK_VIOLET:
.. rst-class:: classref-constant
**DARK_VIOLET** = ``Color(0.5803922, 0, 0.827451, 1)`` :ref:`🔗<class_Color_constant_DARK_VIOLET>`
Colore violetto scuro.
.. _class_Color_constant_DEEP_PINK:
.. rst-class:: classref-constant
**DEEP_PINK** = ``Color(1, 0.078431375, 0.5764706, 1)`` :ref:`🔗<class_Color_constant_DEEP_PINK>`
Colore rosa intenso.
.. _class_Color_constant_DEEP_SKY_BLUE:
.. rst-class:: classref-constant
**DEEP_SKY_BLUE** = ``Color(0, 0.7490196, 1, 1)`` :ref:`🔗<class_Color_constant_DEEP_SKY_BLUE>`
Colore blu cielo intenso.
.. _class_Color_constant_DIM_GRAY:
.. rst-class:: classref-constant
**DIM_GRAY** = ``Color(0.4117647, 0.4117647, 0.4117647, 1)`` :ref:`🔗<class_Color_constant_DIM_GRAY>`
Colore grigio tenue.
.. _class_Color_constant_DODGER_BLUE:
.. rst-class:: classref-constant
**DODGER_BLUE** = ``Color(0.11764706, 0.5647059, 1, 1)`` :ref:`🔗<class_Color_constant_DODGER_BLUE>`
Colore blu Dodger.
.. _class_Color_constant_FIREBRICK:
.. rst-class:: classref-constant
**FIREBRICK** = ``Color(0.69803923, 0.13333334, 0.13333334, 1)`` :ref:`🔗<class_Color_constant_FIREBRICK>`
Colore rosso mattone.
.. _class_Color_constant_FLORAL_WHITE:
.. rst-class:: classref-constant
**FLORAL_WHITE** = ``Color(1, 0.98039216, 0.9411765, 1)`` :ref:`🔗<class_Color_constant_FLORAL_WHITE>`
Colore bianco floreale.
.. _class_Color_constant_FOREST_GREEN:
.. rst-class:: classref-constant
**FOREST_GREEN** = ``Color(0.13333334, 0.54509807, 0.13333334, 1)`` :ref:`🔗<class_Color_constant_FOREST_GREEN>`
Colore verde foresta.
.. _class_Color_constant_FUCHSIA:
.. rst-class:: classref-constant
**FUCHSIA** = ``Color(1, 0, 1, 1)`` :ref:`🔗<class_Color_constant_FUCHSIA>`
Colore fucsia.
.. _class_Color_constant_GAINSBORO:
.. rst-class:: classref-constant
**GAINSBORO** = ``Color(0.8627451, 0.8627451, 0.8627451, 1)`` :ref:`🔗<class_Color_constant_GAINSBORO>`
Colore Gainsboro.
.. _class_Color_constant_GHOST_WHITE:
.. rst-class:: classref-constant
**GHOST_WHITE** = ``Color(0.972549, 0.972549, 1, 1)`` :ref:`🔗<class_Color_constant_GHOST_WHITE>`
Colore bianco fantasma.
.. _class_Color_constant_GOLD:
.. rst-class:: classref-constant
**GOLD** = ``Color(1, 0.84313726, 0, 1)`` :ref:`🔗<class_Color_constant_GOLD>`
Colore oro.
.. _class_Color_constant_GOLDENROD:
.. rst-class:: classref-constant
**GOLDENROD** = ``Color(0.85490197, 0.64705884, 0.1254902, 1)`` :ref:`🔗<class_Color_constant_GOLDENROD>`
Colore verga d'oro.
.. _class_Color_constant_GRAY:
.. rst-class:: classref-constant
**GRAY** = ``Color(0.74509805, 0.74509805, 0.74509805, 1)`` :ref:`🔗<class_Color_constant_GRAY>`
Colore grigio.
.. _class_Color_constant_GREEN:
.. rst-class:: classref-constant
**GREEN** = ``Color(0, 1, 0, 1)`` :ref:`🔗<class_Color_constant_GREEN>`
Colore verde.
.. _class_Color_constant_GREEN_YELLOW:
.. rst-class:: classref-constant
**GREEN_YELLOW** = ``Color(0.6784314, 1, 0.18431373, 1)`` :ref:`🔗<class_Color_constant_GREEN_YELLOW>`
Colore giallo verde.
.. _class_Color_constant_HONEYDEW:
.. rst-class:: classref-constant
**HONEYDEW** = ``Color(0.9411765, 1, 0.9411765, 1)`` :ref:`🔗<class_Color_constant_HONEYDEW>`
Colore melata.
.. _class_Color_constant_HOT_PINK:
.. rst-class:: classref-constant
**HOT_PINK** = ``Color(1, 0.4117647, 0.7058824, 1)`` :ref:`🔗<class_Color_constant_HOT_PINK>`
Colore rosa acceso.
.. _class_Color_constant_INDIAN_RED:
.. rst-class:: classref-constant
**INDIAN_RED** = ``Color(0.8039216, 0.36078432, 0.36078432, 1)`` :ref:`🔗<class_Color_constant_INDIAN_RED>`
Colore rosso indiano.
.. _class_Color_constant_INDIGO:
.. rst-class:: classref-constant
**INDIGO** = ``Color(0.29411766, 0, 0.50980395, 1)`` :ref:`🔗<class_Color_constant_INDIGO>`
Colore indaco.
.. _class_Color_constant_IVORY:
.. rst-class:: classref-constant
**IVORY** = ``Color(1, 1, 0.9411765, 1)`` :ref:`🔗<class_Color_constant_IVORY>`
Colore avorio.
.. _class_Color_constant_KHAKI:
.. rst-class:: classref-constant
**KHAKI** = ``Color(0.9411765, 0.9019608, 0.54901963, 1)`` :ref:`🔗<class_Color_constant_KHAKI>`
Colore cachi.
.. _class_Color_constant_LAVENDER:
.. rst-class:: classref-constant
**LAVENDER** = ``Color(0.9019608, 0.9019608, 0.98039216, 1)`` :ref:`🔗<class_Color_constant_LAVENDER>`
Colore lavanda.
.. _class_Color_constant_LAVENDER_BLUSH:
.. rst-class:: classref-constant
**LAVENDER_BLUSH** = ``Color(1, 0.9411765, 0.9607843, 1)`` :ref:`🔗<class_Color_constant_LAVENDER_BLUSH>`
Colore lavanda rosata.
.. _class_Color_constant_LAWN_GREEN:
.. rst-class:: classref-constant
**LAWN_GREEN** = ``Color(0.4862745, 0.9882353, 0, 1)`` :ref:`🔗<class_Color_constant_LAWN_GREEN>`
Colore verde prato.
.. _class_Color_constant_LEMON_CHIFFON:
.. rst-class:: classref-constant
**LEMON_CHIFFON** = ``Color(1, 0.98039216, 0.8039216, 1)`` :ref:`🔗<class_Color_constant_LEMON_CHIFFON>`
Color limone chiffon.
.. _class_Color_constant_LIGHT_BLUE:
.. rst-class:: classref-constant
**LIGHT_BLUE** = ``Color(0.6784314, 0.84705883, 0.9019608, 1)`` :ref:`🔗<class_Color_constant_LIGHT_BLUE>`
Colore azzurro.
.. _class_Color_constant_LIGHT_CORAL:
.. rst-class:: classref-constant
**LIGHT_CORAL** = ``Color(0.9411765, 0.5019608, 0.5019608, 1)`` :ref:`🔗<class_Color_constant_LIGHT_CORAL>`
Colore corallo chiaro.
.. _class_Color_constant_LIGHT_CYAN:
.. rst-class:: classref-constant
**LIGHT_CYAN** = ``Color(0.8784314, 1, 1, 1)`` :ref:`🔗<class_Color_constant_LIGHT_CYAN>`
Colore ciano chiaro.
.. _class_Color_constant_LIGHT_GOLDENROD:
.. rst-class:: classref-constant
**LIGHT_GOLDENROD** = ``Color(0.98039216, 0.98039216, 0.8235294, 1)`` :ref:`🔗<class_Color_constant_LIGHT_GOLDENROD>`
Colore verga d'oro chiaro.
.. _class_Color_constant_LIGHT_GRAY:
.. rst-class:: classref-constant
**LIGHT_GRAY** = ``Color(0.827451, 0.827451, 0.827451, 1)`` :ref:`🔗<class_Color_constant_LIGHT_GRAY>`
Colore grigio chiaro.
.. _class_Color_constant_LIGHT_GREEN:
.. rst-class:: classref-constant
**LIGHT_GREEN** = ``Color(0.5647059, 0.93333334, 0.5647059, 1)`` :ref:`🔗<class_Color_constant_LIGHT_GREEN>`
Colore verde chiaro.
.. _class_Color_constant_LIGHT_PINK:
.. rst-class:: classref-constant
**LIGHT_PINK** = ``Color(1, 0.7137255, 0.75686276, 1)`` :ref:`🔗<class_Color_constant_LIGHT_PINK>`
Colore rosa chiaro.
.. _class_Color_constant_LIGHT_SALMON:
.. rst-class:: classref-constant
**LIGHT_SALMON** = ``Color(1, 0.627451, 0.47843137, 1)`` :ref:`🔗<class_Color_constant_LIGHT_SALMON>`
Colore salmone chiaro.
.. _class_Color_constant_LIGHT_SEA_GREEN:
.. rst-class:: classref-constant
**LIGHT_SEA_GREEN** = ``Color(0.1254902, 0.69803923, 0.6666667, 1)`` :ref:`🔗<class_Color_constant_LIGHT_SEA_GREEN>`
Colore verde mare chiaro.
.. _class_Color_constant_LIGHT_SKY_BLUE:
.. rst-class:: classref-constant
**LIGHT_SKY_BLUE** = ``Color(0.5294118, 0.80784315, 0.98039216, 1)`` :ref:`🔗<class_Color_constant_LIGHT_SKY_BLUE>`
Colore azzurro cielo chiaro.
.. _class_Color_constant_LIGHT_SLATE_GRAY:
.. rst-class:: classref-constant
**LIGHT_SLATE_GRAY** = ``Color(0.46666667, 0.53333336, 0.6, 1)`` :ref:`🔗<class_Color_constant_LIGHT_SLATE_GRAY>`
Colore grigio ardesia chiaro.
.. _class_Color_constant_LIGHT_STEEL_BLUE:
.. rst-class:: classref-constant
**LIGHT_STEEL_BLUE** = ``Color(0.6901961, 0.76862746, 0.87058824, 1)`` :ref:`🔗<class_Color_constant_LIGHT_STEEL_BLUE>`
Colore blu acciaio chiaro.
.. _class_Color_constant_LIGHT_YELLOW:
.. rst-class:: classref-constant
**LIGHT_YELLOW** = ``Color(1, 1, 0.8784314, 1)`` :ref:`🔗<class_Color_constant_LIGHT_YELLOW>`
Colore giallo chiaro.
.. _class_Color_constant_LIME:
.. rst-class:: classref-constant
**LIME** = ``Color(0, 1, 0, 1)`` :ref:`🔗<class_Color_constant_LIME>`
Colore lime.
.. _class_Color_constant_LIME_GREEN:
.. rst-class:: classref-constant
**LIME_GREEN** = ``Color(0.19607843, 0.8039216, 0.19607843, 1)`` :ref:`🔗<class_Color_constant_LIME_GREEN>`
Colore verde lime.
.. _class_Color_constant_LINEN:
.. rst-class:: classref-constant
**LINEN** = ``Color(0.98039216, 0.9411765, 0.9019608, 1)`` :ref:`🔗<class_Color_constant_LINEN>`
Colore lino.
.. _class_Color_constant_MAGENTA:
.. rst-class:: classref-constant
**MAGENTA** = ``Color(1, 0, 1, 1)`` :ref:`🔗<class_Color_constant_MAGENTA>`
Colore magenta.
.. _class_Color_constant_MAROON:
.. rst-class:: classref-constant
**MAROON** = ``Color(0.6901961, 0.1882353, 0.3764706, 1)`` :ref:`🔗<class_Color_constant_MAROON>`
Colore marrone rossiccio.
.. _class_Color_constant_MEDIUM_AQUAMARINE:
.. rst-class:: classref-constant
**MEDIUM_AQUAMARINE** = ``Color(0.4, 0.8039216, 0.6666667, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_AQUAMARINE>`
Colore acquamarina medio.
.. _class_Color_constant_MEDIUM_BLUE:
.. rst-class:: classref-constant
**MEDIUM_BLUE** = ``Color(0, 0, 0.8039216, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_BLUE>`
Colore blu medio.
.. _class_Color_constant_MEDIUM_ORCHID:
.. rst-class:: classref-constant
**MEDIUM_ORCHID** = ``Color(0.7294118, 0.33333334, 0.827451, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_ORCHID>`
Colore orchidea medio.
.. _class_Color_constant_MEDIUM_PURPLE:
.. rst-class:: classref-constant
**MEDIUM_PURPLE** = ``Color(0.5764706, 0.4392157, 0.85882354, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_PURPLE>`
Colore viola medio.
.. _class_Color_constant_MEDIUM_SEA_GREEN:
.. rst-class:: classref-constant
**MEDIUM_SEA_GREEN** = ``Color(0.23529412, 0.7019608, 0.44313726, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_SEA_GREEN>`
Colore verde mare medio.
.. _class_Color_constant_MEDIUM_SLATE_BLUE:
.. rst-class:: classref-constant
**MEDIUM_SLATE_BLUE** = ``Color(0.48235294, 0.40784314, 0.93333334, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_SLATE_BLUE>`
Colore blu ardesia medio.
.. _class_Color_constant_MEDIUM_SPRING_GREEN:
.. rst-class:: classref-constant
**MEDIUM_SPRING_GREEN** = ``Color(0, 0.98039216, 0.6039216, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_SPRING_GREEN>`
Colore verde primaverile medio.
.. _class_Color_constant_MEDIUM_TURQUOISE:
.. rst-class:: classref-constant
**MEDIUM_TURQUOISE** = ``Color(0.28235295, 0.81960785, 0.8, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_TURQUOISE>`
Colore turchese medio.
.. _class_Color_constant_MEDIUM_VIOLET_RED:
.. rst-class:: classref-constant
**MEDIUM_VIOLET_RED** = ``Color(0.78039217, 0.08235294, 0.52156866, 1)`` :ref:`🔗<class_Color_constant_MEDIUM_VIOLET_RED>`
Colore rosso violaceo medio.
.. _class_Color_constant_MIDNIGHT_BLUE:
.. rst-class:: classref-constant
**MIDNIGHT_BLUE** = ``Color(0.09803922, 0.09803922, 0.4392157, 1)`` :ref:`🔗<class_Color_constant_MIDNIGHT_BLUE>`
Colore blu notte.
.. _class_Color_constant_MINT_CREAM:
.. rst-class:: classref-constant
**MINT_CREAM** = ``Color(0.9607843, 1, 0.98039216, 1)`` :ref:`🔗<class_Color_constant_MINT_CREAM>`
Color crema menta.
.. _class_Color_constant_MISTY_ROSE:
.. rst-class:: classref-constant
**MISTY_ROSE** = ``Color(1, 0.89411765, 0.88235295, 1)`` :ref:`🔗<class_Color_constant_MISTY_ROSE>`
Colore rosa nebbia.
.. _class_Color_constant_MOCCASIN:
.. rst-class:: classref-constant
**MOCCASIN** = ``Color(1, 0.89411765, 0.70980394, 1)`` :ref:`🔗<class_Color_constant_MOCCASIN>`
Colore mocassino.
.. _class_Color_constant_NAVAJO_WHITE:
.. rst-class:: classref-constant
**NAVAJO_WHITE** = ``Color(1, 0.87058824, 0.6784314, 1)`` :ref:`🔗<class_Color_constant_NAVAJO_WHITE>`
Colore bianco Navajo.
.. _class_Color_constant_NAVY_BLUE:
.. rst-class:: classref-constant
**NAVY_BLUE** = ``Color(0, 0, 0.5019608, 1)`` :ref:`🔗<class_Color_constant_NAVY_BLUE>`
Colore blu marino.
.. _class_Color_constant_OLD_LACE:
.. rst-class:: classref-constant
**OLD_LACE** = ``Color(0.99215686, 0.9607843, 0.9019608, 1)`` :ref:`🔗<class_Color_constant_OLD_LACE>`
Colore pizzo antico.
.. _class_Color_constant_OLIVE:
.. rst-class:: classref-constant
**OLIVE** = ``Color(0.5019608, 0.5019608, 0, 1)`` :ref:`🔗<class_Color_constant_OLIVE>`
Colore oliva.
.. _class_Color_constant_OLIVE_DRAB:
.. rst-class:: classref-constant
**OLIVE_DRAB** = ``Color(0.41960785, 0.5568628, 0.13725491, 1)`` :ref:`🔗<class_Color_constant_OLIVE_DRAB>`
Colore verde oliva.
.. _class_Color_constant_ORANGE:
.. rst-class:: classref-constant
**ORANGE** = ``Color(1, 0.64705884, 0, 1)`` :ref:`🔗<class_Color_constant_ORANGE>`
Colore arancione.
.. _class_Color_constant_ORANGE_RED:
.. rst-class:: classref-constant
**ORANGE_RED** = ``Color(1, 0.27058825, 0, 1)`` :ref:`🔗<class_Color_constant_ORANGE_RED>`
Colore rosso arancione.
.. _class_Color_constant_ORCHID:
.. rst-class:: classref-constant
**ORCHID** = ``Color(0.85490197, 0.4392157, 0.8392157, 1)`` :ref:`🔗<class_Color_constant_ORCHID>`
Colore orchidea.
.. _class_Color_constant_PALE_GOLDENROD:
.. rst-class:: classref-constant
**PALE_GOLDENROD** = ``Color(0.93333334, 0.9098039, 0.6666667, 1)`` :ref:`🔗<class_Color_constant_PALE_GOLDENROD>`
Colore verga d'oro pallido.
.. _class_Color_constant_PALE_GREEN:
.. rst-class:: classref-constant
**PALE_GREEN** = ``Color(0.59607846, 0.9843137, 0.59607846, 1)`` :ref:`🔗<class_Color_constant_PALE_GREEN>`
Colore verde pallido.
.. _class_Color_constant_PALE_TURQUOISE:
.. rst-class:: classref-constant
**PALE_TURQUOISE** = ``Color(0.6862745, 0.93333334, 0.93333334, 1)`` :ref:`🔗<class_Color_constant_PALE_TURQUOISE>`
Colore turchese pallido.
.. _class_Color_constant_PALE_VIOLET_RED:
.. rst-class:: classref-constant
**PALE_VIOLET_RED** = ``Color(0.85882354, 0.4392157, 0.5764706, 1)`` :ref:`🔗<class_Color_constant_PALE_VIOLET_RED>`
Colore rosso violaceo pallido.
.. _class_Color_constant_PAPAYA_WHIP:
.. rst-class:: classref-constant
**PAPAYA_WHIP** = ``Color(1, 0.9372549, 0.8352941, 1)`` :ref:`🔗<class_Color_constant_PAPAYA_WHIP>`
Colore frusta di papaya.
.. _class_Color_constant_PEACH_PUFF:
.. rst-class:: classref-constant
**PEACH_PUFF** = ``Color(1, 0.85490197, 0.7254902, 1)`` :ref:`🔗<class_Color_constant_PEACH_PUFF>`
Color pesca.
.. _class_Color_constant_PERU:
.. rst-class:: classref-constant
**PERU** = ``Color(0.8039216, 0.52156866, 0.24705882, 1)`` :ref:`🔗<class_Color_constant_PERU>`
Colore marrone chiaro.
.. _class_Color_constant_PINK:
.. rst-class:: classref-constant
**PINK** = ``Color(1, 0.7529412, 0.79607844, 1)`` :ref:`🔗<class_Color_constant_PINK>`
Colore rosa.
.. _class_Color_constant_PLUM:
.. rst-class:: classref-constant
**PLUM** = ``Color(0.8666667, 0.627451, 0.8666667, 1)`` :ref:`🔗<class_Color_constant_PLUM>`
Colore prugna.
.. _class_Color_constant_POWDER_BLUE:
.. rst-class:: classref-constant
**POWDER_BLUE** = ``Color(0.6901961, 0.8784314, 0.9019608, 1)`` :ref:`🔗<class_Color_constant_POWDER_BLUE>`
Colore blu polvere.
.. _class_Color_constant_PURPLE:
.. rst-class:: classref-constant
**PURPLE** = ``Color(0.627451, 0.1254902, 0.9411765, 1)`` :ref:`🔗<class_Color_constant_PURPLE>`
Colore viola.
.. _class_Color_constant_REBECCA_PURPLE:
.. rst-class:: classref-constant
**REBECCA_PURPLE** = ``Color(0.4, 0.2, 0.6, 1)`` :ref:`🔗<class_Color_constant_REBECCA_PURPLE>`
Colore viola Rebecca.
.. _class_Color_constant_RED:
.. rst-class:: classref-constant
**RED** = ``Color(1, 0, 0, 1)`` :ref:`🔗<class_Color_constant_RED>`
Colore rosso.
.. _class_Color_constant_ROSY_BROWN:
.. rst-class:: classref-constant
**ROSY_BROWN** = ``Color(0.7372549, 0.56078434, 0.56078434, 1)`` :ref:`🔗<class_Color_constant_ROSY_BROWN>`
Colore marrone rosato.
.. _class_Color_constant_ROYAL_BLUE:
.. rst-class:: classref-constant
**ROYAL_BLUE** = ``Color(0.25490198, 0.4117647, 0.88235295, 1)`` :ref:`🔗<class_Color_constant_ROYAL_BLUE>`
Colore blu reale.
.. _class_Color_constant_SADDLE_BROWN:
.. rst-class:: classref-constant
**SADDLE_BROWN** = ``Color(0.54509807, 0.27058825, 0.07450981, 1)`` :ref:`🔗<class_Color_constant_SADDLE_BROWN>`
Colore marrone sella.
.. _class_Color_constant_SALMON:
.. rst-class:: classref-constant
**SALMON** = ``Color(0.98039216, 0.5019608, 0.44705883, 1)`` :ref:`🔗<class_Color_constant_SALMON>`
Colore salmone.
.. _class_Color_constant_SANDY_BROWN:
.. rst-class:: classref-constant
**SANDY_BROWN** = ``Color(0.95686275, 0.6431373, 0.3764706, 1)`` :ref:`🔗<class_Color_constant_SANDY_BROWN>`
Colore marrone sabbia.
.. _class_Color_constant_SEA_GREEN:
.. rst-class:: classref-constant
**SEA_GREEN** = ``Color(0.18039216, 0.54509807, 0.34117648, 1)`` :ref:`🔗<class_Color_constant_SEA_GREEN>`
Colore verde mare.
.. _class_Color_constant_SEASHELL:
.. rst-class:: classref-constant
**SEASHELL** = ``Color(1, 0.9607843, 0.93333334, 1)`` :ref:`🔗<class_Color_constant_SEASHELL>`
Colore conchiglia.
.. _class_Color_constant_SIENNA:
.. rst-class:: classref-constant
**SIENNA** = ``Color(0.627451, 0.32156864, 0.1764706, 1)`` :ref:`🔗<class_Color_constant_SIENNA>`
Colore terra di Siena.
.. _class_Color_constant_SILVER:
.. rst-class:: classref-constant
**SILVER** = ``Color(0.7529412, 0.7529412, 0.7529412, 1)`` :ref:`🔗<class_Color_constant_SILVER>`
Colore argento.
.. _class_Color_constant_SKY_BLUE:
.. rst-class:: classref-constant
**SKY_BLUE** = ``Color(0.5294118, 0.80784315, 0.92156863, 1)`` :ref:`🔗<class_Color_constant_SKY_BLUE>`
Colore azzurro cielo.
.. _class_Color_constant_SLATE_BLUE:
.. rst-class:: classref-constant
**SLATE_BLUE** = ``Color(0.41568628, 0.3529412, 0.8039216, 1)`` :ref:`🔗<class_Color_constant_SLATE_BLUE>`
Colore blu ardesia.
.. _class_Color_constant_SLATE_GRAY:
.. rst-class:: classref-constant
**SLATE_GRAY** = ``Color(0.4392157, 0.5019608, 0.5647059, 1)`` :ref:`🔗<class_Color_constant_SLATE_GRAY>`
Colore grigio ardesia.
.. _class_Color_constant_SNOW:
.. rst-class:: classref-constant
**SNOW** = ``Color(1, 0.98039216, 0.98039216, 1)`` :ref:`🔗<class_Color_constant_SNOW>`
Colore neve.
.. _class_Color_constant_SPRING_GREEN:
.. rst-class:: classref-constant
**SPRING_GREEN** = ``Color(0, 1, 0.49803922, 1)`` :ref:`🔗<class_Color_constant_SPRING_GREEN>`
Colore verde primaverile.
.. _class_Color_constant_STEEL_BLUE:
.. rst-class:: classref-constant
**STEEL_BLUE** = ``Color(0.27450982, 0.50980395, 0.7058824, 1)`` :ref:`🔗<class_Color_constant_STEEL_BLUE>`
Colore blu acciaio.
.. _class_Color_constant_TAN:
.. rst-class:: classref-constant
**TAN** = ``Color(0.8235294, 0.7058824, 0.54901963, 1)`` :ref:`🔗<class_Color_constant_TAN>`
Colore tanno.
.. _class_Color_constant_TEAL:
.. rst-class:: classref-constant
**TEAL** = ``Color(0, 0.5019608, 0.5019608, 1)`` :ref:`🔗<class_Color_constant_TEAL>`
Color verde acqua.
.. _class_Color_constant_THISTLE:
.. rst-class:: classref-constant
**THISTLE** = ``Color(0.84705883, 0.7490196, 0.84705883, 1)`` :ref:`🔗<class_Color_constant_THISTLE>`
Colore cardo.
.. _class_Color_constant_TOMATO:
.. rst-class:: classref-constant
**TOMATO** = ``Color(1, 0.3882353, 0.2784314, 1)`` :ref:`🔗<class_Color_constant_TOMATO>`
Colore pomodoro.
.. _class_Color_constant_TRANSPARENT:
.. rst-class:: classref-constant
**TRANSPARENT** = ``Color(1, 1, 1, 0)`` :ref:`🔗<class_Color_constant_TRANSPARENT>`
Colore trasparente (bianco con zero alfa).
.. _class_Color_constant_TURQUOISE:
.. rst-class:: classref-constant
**TURQUOISE** = ``Color(0.2509804, 0.8784314, 0.8156863, 1)`` :ref:`🔗<class_Color_constant_TURQUOISE>`
Colore turchese.
.. _class_Color_constant_VIOLET:
.. rst-class:: classref-constant
**VIOLET** = ``Color(0.93333334, 0.50980395, 0.93333334, 1)`` :ref:`🔗<class_Color_constant_VIOLET>`
Colore violetto.
.. _class_Color_constant_WEB_GRAY:
.. rst-class:: classref-constant
**WEB_GRAY** = ``Color(0.5019608, 0.5019608, 0.5019608, 1)`` :ref:`🔗<class_Color_constant_WEB_GRAY>`
Colore grigio web.
.. _class_Color_constant_WEB_GREEN:
.. rst-class:: classref-constant
**WEB_GREEN** = ``Color(0, 0.5019608, 0, 1)`` :ref:`🔗<class_Color_constant_WEB_GREEN>`
Colore verde web.
.. _class_Color_constant_WEB_MAROON:
.. rst-class:: classref-constant
**WEB_MAROON** = ``Color(0.5019608, 0, 0, 1)`` :ref:`🔗<class_Color_constant_WEB_MAROON>`
Colore marrone web.
.. _class_Color_constant_WEB_PURPLE:
.. rst-class:: classref-constant
**WEB_PURPLE** = ``Color(0.5019608, 0, 0.5019608, 1)`` :ref:`🔗<class_Color_constant_WEB_PURPLE>`
Colore viola web.
.. _class_Color_constant_WHEAT:
.. rst-class:: classref-constant
**WHEAT** = ``Color(0.9607843, 0.87058824, 0.7019608, 1)`` :ref:`🔗<class_Color_constant_WHEAT>`
Colore grano.
.. _class_Color_constant_WHITE:
.. rst-class:: classref-constant
**WHITE** = ``Color(1, 1, 1, 1)`` :ref:`🔗<class_Color_constant_WHITE>`
Colore bianco.
.. _class_Color_constant_WHITE_SMOKE:
.. rst-class:: classref-constant
**WHITE_SMOKE** = ``Color(0.9607843, 0.9607843, 0.9607843, 1)`` :ref:`🔗<class_Color_constant_WHITE_SMOKE>`
Colore fumo bianco.
.. _class_Color_constant_YELLOW:
.. rst-class:: classref-constant
**YELLOW** = ``Color(1, 1, 0, 1)`` :ref:`🔗<class_Color_constant_YELLOW>`
Colore giallo.
.. _class_Color_constant_YELLOW_GREEN:
.. rst-class:: classref-constant
**YELLOW_GREEN** = ``Color(0.6039216, 0.8039216, 0.19607843, 1)`` :ref:`🔗<class_Color_constant_YELLOW_GREEN>`
Colore giallo-verde.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni delle proprietà
------------------------------------------------------
.. _class_Color_property_a:
.. rst-class:: classref-property
:ref:`float<class_float>` **a** = ``1.0`` :ref:`🔗<class_Color_property_a>`
The color's alpha component, typically on the range of 0 to 1. A value of 0 means that the color is fully transparent. A value of 1 means that the color is fully opaque.
\ **Note:** The alpha channel is always stored with linear encoding, regardless of the encoding of the other color channels. The :ref:`linear_to_srgb()<class_Color_method_linear_to_srgb>` and :ref:`srgb_to_linear()<class_Color_method_srgb_to_linear>` methods do not affect the alpha channel.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_a8:
.. rst-class:: classref-property
:ref:`int<class_int>` **a8** = ``255`` :ref:`🔗<class_Color_property_a8>`
Wrapper per :ref:`a<class_Color_property_a>` che utilizza l'intervallo da 0 a 255, invece che da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_b:
.. rst-class:: classref-property
:ref:`float<class_float>` **b** = ``0.0`` :ref:`🔗<class_Color_property_b>`
Il componente blu del colore, solitamente nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_b8:
.. rst-class:: classref-property
:ref:`int<class_int>` **b8** = ``0`` :ref:`🔗<class_Color_property_b8>`
Wrapper per :ref:`b<class_Color_property_b>` che utilizza l'intervallo da 0 a 255, invece che da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_g:
.. rst-class:: classref-property
:ref:`float<class_float>` **g** = ``0.0`` :ref:`🔗<class_Color_property_g>`
Il componente verde del colore, solitamente nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_g8:
.. rst-class:: classref-property
:ref:`int<class_int>` **g8** = ``0`` :ref:`🔗<class_Color_property_g8>`
Wrapper per :ref:`g<class_Color_property_g>` che utilizza l'intervallo da 0 a 255, invece che da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_h:
.. rst-class:: classref-property
:ref:`float<class_float>` **h** = ``0.0`` :ref:`🔗<class_Color_property_h>`
Tonalità HSV di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_ok_hsl_h:
.. rst-class:: classref-property
:ref:`float<class_float>` **ok_hsl_h** = ``0.0`` :ref:`🔗<class_Color_property_ok_hsl_h>`
La tonalità OKHSL di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_ok_hsl_l:
.. rst-class:: classref-property
:ref:`float<class_float>` **ok_hsl_l** = ``0.0`` :ref:`🔗<class_Color_property_ok_hsl_l>`
La luminosità OKHSL di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_ok_hsl_s:
.. rst-class:: classref-property
:ref:`float<class_float>` **ok_hsl_s** = ``0.0`` :ref:`🔗<class_Color_property_ok_hsl_s>`
La saturazione OKHSL di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_r:
.. rst-class:: classref-property
:ref:`float<class_float>` **r** = ``0.0`` :ref:`🔗<class_Color_property_r>`
Il componente rosso del colore, solitamente nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_r8:
.. rst-class:: classref-property
:ref:`int<class_int>` **r8** = ``0`` :ref:`🔗<class_Color_property_r8>`
Wrapper per :ref:`r<class_Color_property_r>` che utilizza l'intervallo da 0 a 255, invece che da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_s:
.. rst-class:: classref-property
:ref:`float<class_float>` **s** = ``0.0`` :ref:`🔗<class_Color_property_s>`
La saturazione HSV di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-item-separator
----
.. _class_Color_property_v:
.. rst-class:: classref-property
:ref:`float<class_float>` **v** = ``0.0`` :ref:`🔗<class_Color_property_v>`
Il valore HSV (luminosità) di questo colore, nell'intervallo da 0 a 1.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei costruttori
------------------------------------------------------
.. _class_Color_constructor_Color:
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ ) :ref:`🔗<class_Color_constructor_Color>`
Costruisce un **Color** predefinito dal nero opaco. È lo stesso di :ref:`BLACK<class_Color_constant_BLACK>`.
\ **Nota:** In C#, costruisce un **Color** con tutti i suoi componenti impostati su ``0.0`` (nero trasparente).
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ from\: :ref:`Color<class_Color>`, alpha\: :ref:`float<class_float>`\ )
Costruisce un **Color** dal colore esistente, con :ref:`a<class_Color_property_a>` impostato sul valore ``alpha`` specificato.
.. tabs::
.. code-tab:: gdscript
var red = Color(Color.RED, 0.2) # Rosso 20% opaco.
.. code-tab:: csharp
var red = new Color(Colors.Red, 0.2f); // Rosso 20% opaco.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ from\: :ref:`Color<class_Color>`\ )
Costruisce un **Color** come copia del **Color** specificato.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ code\: :ref:`String<class_String>`\ )
Costruisce un **Color** da un codice colore HTML o dal nome di un colore standardizzato. I nomi dei colori supportati sono gli stessi delle costanti.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ code\: :ref:`String<class_String>`, alpha\: :ref:`float<class_float>`\ )
Costruisce un **Color** sia da un codice colore HTML o dal nome di un colore standardizzato, con ``alpha`` sulla gamma di 0.0 a 1.0. I nomi dei colori supportati sono gli stessi delle costanti.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ r\: :ref:`float<class_float>`, g\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`\ )
Constructs a **Color** from RGB values, typically between 0.0 and 1.0. :ref:`a<class_Color_property_a>` is set to 1.0.
.. tabs::
.. code-tab:: gdscript
var color = Color(0.2, 1.0, 0.7) # Similar to `Color.from_rgba8(51, 255, 178, 255)`
.. code-tab:: csharp
var color = new Color(0.2f, 1.0f, 0.7f); // Similar to `Color.Color8(51, 255, 178, 255)`
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`Color<class_Color>` **Color**\ (\ r\: :ref:`float<class_float>`, g\: :ref:`float<class_float>`, b\: :ref:`float<class_float>`, a\: :ref:`float<class_float>`\ )
Constructs a **Color** from RGBA values, typically between 0.0 and 1.0.
.. tabs::
.. code-tab:: gdscript
var color = Color(0.2, 1.0, 0.7, 0.8) # Similar to `Color.from_rgba8(51, 255, 178, 204)`
.. code-tab:: csharp
var color = new Color(0.2f, 1.0f, 0.7f, 0.8f); // Similar to `Color.Color8(51, 255, 178, 255, 204)`
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_Color_method_blend:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **blend**\ (\ over\: :ref:`Color<class_Color>`\ ) |const| :ref:`🔗<class_Color_method_blend>`
Restituisce un nuovo colore risultante dalla sovrapposizione di questo colore sul colore specificato. In un programma di pittura, puoi immaginarlo come il colore ``over`` dipinto su questo colore (incluso alfa).
.. tabs::
.. code-tab:: gdscript
var bg = Color(0.0, 1.0, 0.0, 0.5) # Verde con alfa del 50%
var fg = Color(1.0, 0.0, 0.0, 0.5) # Rosso con alfa del 50%
var blended_color = bg.blend(fg) # Marrone con alfa del 75%
.. code-tab:: csharp
var bg = new Color(0.0f, 1.0f, 0.0f, 0.5f); // Verde con alfa del 50%
var fg = new Color(1.0f, 0.0f, 0.0f, 0.5f); // Rosso con alfa del 50%
Color blendedColor = bg.Blend(fg); // Marrone con alfa del 75%
.. rst-class:: classref-item-separator
----
.. _class_Color_method_clamp:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **clamp**\ (\ min\: :ref:`Color<class_Color>` = Color(0, 0, 0, 0), max\: :ref:`Color<class_Color>` = Color(1, 1, 1, 1)\ ) |const| :ref:`🔗<class_Color_method_clamp>`
Restituisce un nuovo colore con tutti i componenti limitati tra i componenti di ``min`` e ``max``, eseguendo :ref:`@GlobalScope.clamp()<class_@GlobalScope_method_clamp>` su ciascun componente.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_darkened:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **darkened**\ (\ amount\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Color_method_darkened>`
Restituisce un nuovo colore che è il risultato di scurire questo colore per la quantità specificata ``amount`` (rapporto da 0,0 a 1,0). Vedi anche :ref:`lightened()<class_Color_method_lightened>`.
.. tabs::
.. code-tab:: gdscript
var green = Color(0.0, 1.0, 0.0)
var darkgreen = green.darkened(0.2) # 20% più scuro del verde normale
.. code-tab:: csharp
var green = new Color(0.0f, 1.0f, 0-0f);
Color darkgreen = green.Darkened(0.2f); // 20% più scuro del verde normale
.. rst-class:: classref-item-separator
----
.. _class_Color_method_from_hsv:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **from_hsv**\ (\ h\: :ref:`float<class_float>`, s\: :ref:`float<class_float>`, v\: :ref:`float<class_float>`, alpha\: :ref:`float<class_float>` = 1.0\ ) |static| :ref:`🔗<class_Color_method_from_hsv>`
Costruisce un colore da un `profilo HSV <https://it.wikipedia.org/wiki/Hue_Saturation_Brightness>`__. La tonalità (``h``), la saturazione (``s``) e il valore (``v``) sono in genere compresi tra 0,0 e 1,0.
.. tabs::
.. code-tab:: gdscript
var color = Color.from_hsv(0.58, 0.5, 0.79, 0.8)
.. code-tab:: csharp
var color = Color.FromHsv(0.58f, 0.5f, 0.79f, 0.8f);
.. rst-class:: classref-item-separator
----
.. _class_Color_method_from_ok_hsl:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **from_ok_hsl**\ (\ h\: :ref:`float<class_float>`, s\: :ref:`float<class_float>`, l\: :ref:`float<class_float>`, alpha\: :ref:`float<class_float>` = 1.0\ ) |static| :ref:`🔗<class_Color_method_from_ok_hsl>`
Costruisce un colore da un `profilo HSL OK <https://bottosson.github.io/posts/colorpicker/>`__. La tonalità (``h``), la saturazione (``s``) e la luminosità (``l``) sono in genere comprese tra 0,0 e 1,0.
.. tabs::
.. code-tab:: gdscript
var color = Color.from_ok_hsl(0.58, 0.5, 0.79, 0.8)
.. code-tab:: csharp
var color = Color.FromOkHsl(0.58f, 0.5f, 0.79f, 0.8f);
.. rst-class:: classref-item-separator
----
.. _class_Color_method_from_rgba8:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **from_rgba8**\ (\ r8\: :ref:`int<class_int>`, g8\: :ref:`int<class_int>`, b8\: :ref:`int<class_int>`, a8\: :ref:`int<class_int>` = 255\ ) |static| :ref:`🔗<class_Color_method_from_rgba8>`
Restituisce un **Color** costruito da rosso (``r8``), verde (``g8``), blu (``b8``), e facoltativamente alfa (``a8``) canali interi, ciascuno diviso da ``255.0`` per il loro valore finale.
::
var red = Color8(255, 0, 0) # Uguale a Color(1, 0, 0).
var dark_blue = Color8(0, 0, 51) # Uguale a Color(0, 0, 0.2).
var my_color = Color8(306, 255, 0, 102) # Uguale a Color(1.2, 1, 0, 0.4).
\ **Nota:** A causa della minore precisione di :ref:`from_rgba8()<class_Color_method_from_rgba8>` rispetto al costruttore standard di **Color**, un colore creato con :ref:`from_rgba8()<class_Color_method_from_rgba8>` generalmente non sarà uguale allo stesso colore creato con il costruttore standard di **Color**. Utilizza :ref:`is_equal_approx()<class_Color_method_is_equal_approx>` per i confronti per evitare problemi d'errori di precisione in virgola mobile.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_from_rgbe9995:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **from_rgbe9995**\ (\ rgbe\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_Color_method_from_rgbe9995>`
Decodifica un **Color** da un intero in formato RGBE9995. Vedi :ref:`Image.FORMAT_RGBE9995<class_Image_constant_FORMAT_RGBE9995>`.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_from_string:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **from_string**\ (\ str\: :ref:`String<class_String>`, default\: :ref:`Color<class_Color>`\ ) |static| :ref:`🔗<class_Color_method_from_string>`
Crea un **Color** dalla stringa specificata, che può essere un codice colore HTML o un colore con nome (senza distinzione tra maiuscole e minuscole). Restituisce ``default`` se il colore non può essere dedotto dalla stringa.
Se desideri creare un colore da stringa in un'espressione costante, utilizza invece il costruttore equivalente (ad esempio ``Color("color string")``).
.. rst-class:: classref-item-separator
----
.. _class_Color_method_get_luminance:
.. rst-class:: classref-method
:ref:`float<class_float>` **get_luminance**\ (\ ) |const| :ref:`🔗<class_Color_method_get_luminance>`
Returns the light intensity of the color, as a value between 0.0 and 1.0 (inclusive). This is useful when determining light or dark color. Colors with a luminance smaller than 0.5 can be generally considered dark.
\ **Note:** :ref:`get_luminance()<class_Color_method_get_luminance>` relies on the color using linear encoding to return an accurate relative luminance value. If the color uses the default nonlinear sRGB encoding, use :ref:`srgb_to_linear()<class_Color_method_srgb_to_linear>` to convert it to linear encoding first.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_hex:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **hex**\ (\ hex\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_Color_method_hex>`
Restituisce il **Color** associato all'intero ``hex`` fornito in formato RGBA a 32 bit (8 bit per canale). Questo metodo è l'inverso di :ref:`to_rgba32()<class_Color_method_to_rgba32>`.
In GDScript e C#, l':ref:`int<class_int>` è meglio visualizzato con la notazione esadecimale (prefisso ``"0x"``, che lo rende ``"0xRRGGBBAA"``).
.. tabs::
.. code-tab:: gdscript
var red = Color.hex(0xff0000ff)
var dark_cyan = Color.hex(0x008b8bff)
var my_color = Color.hex(0xbbefd2a4)
.. code-tab:: csharp
var red = new Color(0xff0000ff);
var dark_cyan = new Color(0x008b8bff);
var my_color = new Color(0xbbefd2a4);
Se si desidera utilizzare la notazione esadecimale in un'espressione costante, utilizza invece il costruttore equivalente (ad esempio ``Color(0xRRGGBBAA)``).
.. rst-class:: classref-item-separator
----
.. _class_Color_method_hex64:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **hex64**\ (\ hex\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_Color_method_hex64>`
Restituisce il **Color** associato all'intero ``hex`` fornito in formato RGBA a 64 bit (16 bit per canale). Questo metodo è l'inverso di :ref:`to_rgba64()<class_Color_method_to_rgba64>`.
In GDScript e C#, l':ref:`int<class_int>` è meglio visualizzato con la notazione esadecimale (``"0x"`` prefisso, che lo rende ``"0xRRRRGGGGBBBBAAAA"``).
.. rst-class:: classref-item-separator
----
.. _class_Color_method_html:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **html**\ (\ rgba\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_Color_method_html>`
Restituisce un nuovo colore da ``rgba``, una stringa di colore esadecimale HTML. ``rgba`` non è sensibile alle maiuscole e minuscole e può essere preceduto da un cancelletto (``#``).
\ ``rgba`` deve essere una stringa di colore esadecimale valida a tre o sei cifre e può contenere un valore di canale alfa. Se ``rgba`` non contiene un valore di canale alfa, è applicato un valore di canale alfa di 1,0. Se ``rgba`` non è valido, restituisce un colore vuoto.
.. tabs::
.. code-tab:: gdscript
var blue = Color.html("#0000ff") # blue è Color(0.0, 0.0, 1.0, 1.0)
var green = Color.html("#0F0") # green è Color(0.0, 1.0, 0.0, 1.0)
var col = Color.html("663399cc") # col è Color(0.4, 0.2, 0.6, 0.8)
.. code-tab:: csharp
var blue = Color.FromHtml("#0000ff"); // blue è Color(0.0, 0.0, 1.0, 1.0)
var green = Color.FromHtml("#0F0"); // green è Color(0.0, 1.0, 0.0, 1.0)
var col = Color.FromHtml("663399cc"); // col è Color(0.4, 0.2, 0.6, 0.8)
.. rst-class:: classref-item-separator
----
.. _class_Color_method_html_is_valid:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **html_is_valid**\ (\ color\: :ref:`String<class_String>`\ ) |static| :ref:`🔗<class_Color_method_html_is_valid>`
Restituisce ``true`` se ``color`` è una stringa di colore esadecimale HTML valida. La stringa deve essere un valore esadecimale (senza distinzione tra maiuscole e minuscole) di 3, 4, 6 o 8 cifre e può essere preceduta da un cancelletto (``#``). Questo metodo è identico a :ref:`String.is_valid_html_color()<class_String_method_is_valid_html_color>`.
.. tabs::
.. code-tab:: gdscript
Color.html_is_valid("#55aaFF") # Restituisce true
Color.html_is_valid("#55AAFF20") # Restituisce true
Color.html_is_valid("55AAFF") # Restituisce true
Color.html_is_valid("#F2C") # Restituisce true
Color.html_is_valid("#AABBC") # Restituisce false
Color.html_is_valid("#55aaFF5") # Restituisce false
.. code-tab:: csharp
Color.HtmlIsValid("#55AAFF"); // Restituisce true
Color.HtmlIsValid("#55AAFF20"); // Restituisce true
Color.HtmlIsValid("55AAFF"); // Restituisce true
Color.HtmlIsValid("#F2C"); // Restituisce true
Color.HtmlIsValid("#AABBC"); // Restituisce false
Color.HtmlIsValid("#55aaFF5"); // Restituisce false
.. rst-class:: classref-item-separator
----
.. _class_Color_method_inverted:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **inverted**\ (\ ) |const| :ref:`🔗<class_Color_method_inverted>`
Restituisce il colore con i suoi componenti :ref:`r<class_Color_property_r>`, :ref:`g<class_Color_property_g>` e :ref:`b<class_Color_property_b>` invertiti (``(1 - r, 1 - g, 1 - b, a)``).
.. tabs::
.. code-tab:: gdscript
var black = Color.WHITE.inverted()
var color = Color(0.3, 0.4, 0.9)
var inverted_color = color.inverted() # Equivalente a `Color(0.7, 0.6, 0.1)`
.. code-tab:: csharp
var black = Colors.White.Inverted();
var color = new Color(0.3f, 0.4f, 0.9f);
Color invertedColor = color.Inverted(); // Equivalente a `new Color(0.7f, 0.6f, 0.1f)`
.. rst-class:: classref-item-separator
----
.. _class_Color_method_is_equal_approx:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_equal_approx**\ (\ to\: :ref:`Color<class_Color>`\ ) |const| :ref:`🔗<class_Color_method_is_equal_approx>`
Restituisce ``true`` se questo colore e ``to`` sono approssimativamente eguali, chiamando :ref:`@GlobalScope.is_equal_approx()<class_@GlobalScope_method_is_equal_approx>` su ogni componente.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_lerp:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **lerp**\ (\ to\: :ref:`Color<class_Color>`, weight\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Color_method_lerp>`
Restituisce l'interpolazione lineare tra i componenti di questo colore e i componenti di ``to``. Il fattore di interpolazione ``weight`` dovrebbe essere compreso tra 0,0 e 1,0 (inclusi). Vedi anche :ref:`@GlobalScope.lerp()<class_@GlobalScope_method_lerp>`.
.. tabs::
.. code-tab:: gdscript
var red = Color(1.0, 0.0, 0.0)
var aqua = Color(0.0, 1.0, 0.8)
red.lerp(aqua, 0.2) # Restituisce Color(0.8, 0.2, 0.16)
red.lerp(aqua, 0.5) # Restituisce Color(0.5, 0.5, 0.4)
red.lerp(aqua, 1.0) # Restituisce Color(0.0, 1.0, 0.8)
.. code-tab:: csharp
var red = new Color(1.0f, 0.0f, 0.0f);
var aqua = new Color(0.0f, 1.0f, 0.8f);
red.Lerp(aqua, 0.2f); // Restituisce Color(0.8f, 0.2f, 0.16f)
red.Lerp(aqua, 0.5f); // Restituisce Color(0.5f, 0.5f, 0.4f)
red.Lerp(aqua, 1.0f); // Restituisce Color(0.0f, 1.0f, 0.8f)
.. rst-class:: classref-item-separator
----
.. _class_Color_method_lightened:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **lightened**\ (\ amount\: :ref:`float<class_float>`\ ) |const| :ref:`🔗<class_Color_method_lightened>`
Restituisce un nuovo colore che è il risultato di schiarire questo colore per la quantità specificata ``amount`` (rapporto da 0,0 a 1,0). Vedi anche :ref:`darkened()<class_Color_method_darkened>`.
.. tabs::
.. code-tab:: gdscript
var green = Color(0.0, 1.0, 0.0)
var light_green = green.lightened(0.2) # 20% più chiaro del verde normale
.. code-tab:: csharp
var green = new Color(0.0f, 1.0f, 0.0f);
Color lightGreen = green.Lightened(0.2f); // 20% più chiaro del verde normale
.. rst-class:: classref-item-separator
----
.. _class_Color_method_linear_to_srgb:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **linear_to_srgb**\ (\ ) |const| :ref:`🔗<class_Color_method_linear_to_srgb>`
Returns a copy of the color that is encoded using the `nonlinear sRGB transfer function <https://en.wikipedia.org/wiki/SRGB>`__. This method requires the original color to use linear encoding. See also :ref:`srgb_to_linear()<class_Color_method_srgb_to_linear>` which performs the opposite operation.
\ **Note:** The color's alpha channel (:ref:`a<class_Color_property_a>`) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_srgb_to_linear:
.. rst-class:: classref-method
:ref:`Color<class_Color>` **srgb_to_linear**\ (\ ) |const| :ref:`🔗<class_Color_method_srgb_to_linear>`
Returns a copy of the color that uses linear encoding. This method requires the original color to be encoded using the `nonlinear sRGB transfer function <https://en.wikipedia.org/wiki/SRGB>`__. See also :ref:`linear_to_srgb()<class_Color_method_linear_to_srgb>` which performs the opposite operation.
\ **Note:** The color's alpha channel (:ref:`a<class_Color_property_a>`) is not affected. The alpha channel is always stored with linear encoding, regardless of the color space of the other color channels.
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_abgr32:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_abgr32**\ (\ ) |const| :ref:`🔗<class_Color_method_to_abgr32>`
Restituisce il colore convertito in un intero a 32 bit in formato ABGR (ogni componente è di 8 bit). ABGR è la versione invertita del formato RGBA predefinito.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_abgr32()) # Stampa 4281565439
.. code-tab:: csharp
var color = new Color(1.0f, 0.5f, 0.2f);
GD.Print(color.ToAbgr32()); // Stampa 4281565439
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_abgr64:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_abgr64**\ (\ ) |const| :ref:`🔗<class_Color_method_to_abgr64>`
Restituisce il colore convertito in un intero a 64 bit in formato ABGR (ogni componente è di 16 bit). ABGR è la versione invertita del formato RGBA predefinito.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_abgr64()) # Stampa -225178692812801
.. code-tab:: csharp
var color = new Color(1.0f, 0.5f, 0.2f);
GD.Print(color.ToAbgr64()); // Stampa -225178692812801
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_argb32:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_argb32**\ (\ ) |const| :ref:`🔗<class_Color_method_to_argb32>`
Restituisce il colore convertito in un intero a 32 bit in formato ARGB (ogni componente è di 8 bit). ARGB è più compatibile con DirectX.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_argb32()) # Stampa 4294934323
.. code-tab:: csharp
var color = new Color(1.0f, 0.5f, 0.2f);
GD.Print(color.ToArgb32()); // Stampa 4294934323
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_argb64:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_argb64**\ (\ ) |const| :ref:`🔗<class_Color_method_to_argb64>`
Restituisce il colore convertito in un intero a 64 bit in formato ARGB (ogni componente è di 16 bit). ARGB è più compatibile con DirectX.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_argb64()) # Stampa -2147470541
.. code-tab:: csharp
var color = new Color(1.0f, 0.5f, 0.2f);
GD.Print(color.ToArgb64()); // Stampa -2147470541
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_html:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_html**\ (\ with_alpha\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_Color_method_to_html>`
Restituisce il colore convertito in un :ref:`String<class_String>` di colore esadecimale HTML in formato RGBA, senza il prefisso cancelletto (``#``).
Impostando ``with_alpha`` su ``false``, si esclude l'alfa dalla stringa esadecimale, utilizzando il formato RGB anziché il formato RGBA.
.. tabs::
.. code-tab:: gdscript
var white = Color(1, 1, 1, 0.5)
var with_alpha = white.to_html() # Restituisce "ffffff7f"
var without_alpha = white.to_html(false) # Restituisce "ffffff"
.. code-tab:: csharp
var white = new Color(1, 1, 1, 0.5f);
string withAlpha = white.ToHtml(); // Restituisce "ffffff7f"
string withoutAlpha = white.ToHtml(false); // Restituisce "ffffff"
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_rgba32:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_rgba32**\ (\ ) |const| :ref:`🔗<class_Color_method_to_rgba32>`
Restituisce il colore convertito in un intero a 32 bit in formato RGBA (ogni componente è di 8 bit). RGBA è il formato predefinito di Godot. Questo metodo è l'inverso di :ref:`hex()<class_Color_method_hex>`.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_rgba32()) # Stampa 4286526463
.. code-tab:: csharp
var color = new Color(1, 0.5f, 0.2f);
GD.Print(color.ToRgba32()); // Stampa 4286526463
.. rst-class:: classref-item-separator
----
.. _class_Color_method_to_rgba64:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_rgba64**\ (\ ) |const| :ref:`🔗<class_Color_method_to_rgba64>`
Restituisce il colore convertito in un intero a 64 bit in formato RGBA (ogni componente è di 16 bit). RGBA è il formato predefinito di Godot. Questo metodo è l'inverso di :ref:`hex64()<class_Color_method_hex64>`.
.. tabs::
.. code-tab:: gdscript
var color = Color(1, 0.5, 0.2)
print(color.to_rgba64()) # Stampa -140736629309441
.. code-tab:: csharp
var color = new Color(1, 0.5f, 0.2f);
GD.Print(color.ToRgba64()); // Stampa -140736629309441
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni degli operatori
------------------------------------------------------
.. _class_Color_operator_neq_Color:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_neq_Color>`
Restituisce ``true`` se i colori non sono esattamente eguali.
\ **Note:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()<class_Color_method_is_equal_approx>`, che è più affidabile.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_mul_Color:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator ***\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_mul_Color>`
Moltiplica ogni componente del **Color** dai componenti del **Color** specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_mul_float:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Color_operator_mul_float>`
Moltiplica ogni componente del **Color** dal :ref:`float<class_float>` specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_mul_int:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Color_operator_mul_int>`
Moltiplica ogni componente del **Color** dal :ref:`int<class_int>` specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_sum_Color:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator +**\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_sum_Color>`
Aggiunge ogni componente del **Color** ai componenti del **Color** specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_dif_Color:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator -**\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_dif_Color>`
Sottrae ogni componente del **Color** ai componenti del **Color** specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_div_Color:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator /**\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_div_Color>`
Divide ogni componente del **Color** dai componenti del **Color** specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_div_float:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_Color_operator_div_float>`
Divide ogni componente del **Color** dal :ref:`float<class_float>` specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_div_int:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Color_operator_div_int>`
Divide ogni componente del **Color** dal :ref:`int<class_int>` specificato.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_eq_Color:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_Color_operator_eq_Color>`
Restituisce ``true`` se i colori sono esattamente eguali.
\ **Note:** A causa di errori di precisione per virgola mobile, considera invece utilizzare :ref:`is_equal_approx()<class_Color_method_is_equal_approx>`, che è più affidabile.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_idx_int:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Color_operator_idx_int>`
Accede ai componenti del colore utilizzando il loro indice. ``[0]`` è equivalente a :ref:`r<class_Color_property_r>`, ``[1]`` è equivalente a :ref:`g<class_Color_property_g>`, ``[2]`` è equivalente a :ref:`b<class_Color_property_b>`, e ``[3]`` è equivalente a :ref:`a<class_Color_property_a>`.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_unplus:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator unary+**\ (\ ) :ref:`🔗<class_Color_operator_unplus>`
Restituisce lo stesso valore come se ``+`` non ci fosse. Il ``+`` unario non fa nulla, ma a volte può rendere il tuo codice più leggibile.
.. rst-class:: classref-item-separator
----
.. _class_Color_operator_unminus:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator unary-**\ (\ ) :ref:`🔗<class_Color_operator_unminus>`
Inverte il colore specificato. Ciò equivale a ``Color.WHITE - c`` o ``Color(1 - c.r, 1 - c.g, 1 - c.b, 1 - c.a)``. A differenza di :ref:`inverted()<class_Color_method_inverted>`, anche il componente :ref:`a<class_Color_property_a>` è invertito.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink