Color

public Color(Color c, float a = 1f);

Копирует только RGB из c и заменяет альфу значением a. Вызов new Color(c) делает альфу равной 1, даже если c был прозрачным. Для точной копии структуры используйте Color copy = c.

public Color(float r, float g, float b, float a = 1f);

Сохраняет переданные RGBA без ограничения диапазона и преобразования цветового пространства. При отсутствии a альфа равна 1. Это отличается от default(Color), где все четыре компонента равны 0.

public Color(string code);

Разбирает корректный HTML-код либо имя из Colors. Регистр имени не важен; пробелы, дефисы, подчёркивания, апострофы и точки в имени удаляются. Неизвестное значение вызывает ArgumentOutOfRangeException. Для ввода пользователя используйте FromString с резервным цветом либо HtmlIsValid перед FromHtml.

public Color(string code, float alpha);

Разбирает code так же, как конструктор Color(string), затем заменяет его альфу значением alpha без ограничения диапазона. Альфа из HTML-кода не умножается, а заменяется. Некорректное значение вызывает ArgumentOutOfRangeException.

public Color(uint rgba);

Читает целое 0xRRGGBBAA: по 8 бит на канал, R в старших битах, A в младших. Делит каждый канал на 255. Это порядок разрядов числа, а не порядок байтов памяти. 24-битный RGB без альфы сюда не подходит: для красного используйте new Color(0xff0000ffU).

public Color(ulong rgba);

Читает целое 0xRRRRGGGGBBBBAAAA: по 16 бит на канал, R в старших битах, A в младших. Делит каждый канал на 65535. Это порядок разрядов числа, а не порядок байтов памяти. Восстановление через ToRgba64 сохраняет проверенные 16-битные каналы.

public int A8 { get; set; }

Чтение: (int)Math.Round(A * 255), середины округляются к чётному. Запись: A = value / 255f. Это int, не byte; ограничения 0…255 нет: запись 510 даёт компоненту 2. Для обычного 8-битного цвета используйте допустимый диапазон и конечные значения.

public int B8 { get; set; }

Чтение: (int)Math.Round(B * 255), середины округляются к чётному. Запись: B = value / 255f. Это int, не byte; ограничения 0…255 нет: запись 510 даёт компоненту 2. Для обычного 8-битного цвета используйте допустимый диапазон и конечные значения.

public int G8 { get; set; }

Чтение: (int)Math.Round(G * 255), середины округляются к чётному. Запись: G = value / 255f. Это int, не byte; ограничения 0…255 нет: запись 510 даёт компоненту 2. Для обычного 8-битного цвета используйте допустимый диапазон и конечные значения.

public float H { get; set; }

Оттенок HSV в оборотах; для обычного RGB диапазон 0…1. При одинаковых R, G и B возвращает 0: оттенок серого не сохраняется отдельно. Запись пересоздаёт RGB через FromHsv(value, S, V, A), сохраняя альфу. Перед записью нормализуйте отрицательные оттенки.

public float this[int index] { get; set; }

Индексатор RGBA: 0 → R, 1 → G, 2 → B, 3 → A. Чтение и запись вне 0…3 вызывают ArgumentOutOfRangeException. Запись не ограничивает значение канала.

public float Luminance { get; }

Вычисляет 0.2126 * R + 0.7152 * G + 0.0722 * B, игнорируя альфу. Для относительной яркости входной RGB должен быть линейным; для sRGB используйте color.SrgbToLinear().Luminance. Результат не ограничен 0…1: например, RGB = (2, 2, 2) даёт 2. Сам по себе не является проверкой доступности текста или контраста фона.

public float OkHslH { get; set; }

Оттенок OKHSL, вычисляемая из текущего sRGB. Нативное чтение ограничивает результат 0…1, а NaN результата заменяет на 0. Оттенок измеряется в оборотах, не градусах. Запись пересоздаёт RGB через FromOkHsl, сохраняя текущие OkHslS, OkHslL в пределах точности преобразования. При этом весь RGBA ограничивается 0…1: даже запись только OkHslH может изменить ранее выходившую за диапазон альфу. Не используйте для сохранения HDR-диапазона.

public float OkHslL { get; set; }

Светлота OKHSL, вычисляемая из текущего sRGB. Нативное чтение ограничивает результат 0…1, а NaN результата заменяет на 0. Запись пересоздаёт RGB через FromOkHsl, сохраняя текущие OkHslH, OkHslS в пределах точности преобразования. При этом весь RGBA ограничивается 0…1: даже запись только OkHslL может изменить ранее выходившую за диапазон альфу. Не используйте для сохранения HDR-диапазона.

public float OkHslS { get; set; }

Насыщенность OKHSL, вычисляемая из текущего sRGB. Нативное чтение ограничивает результат 0…1, а NaN результата заменяет на 0. Запись пересоздаёт RGB через FromOkHsl, сохраняя текущие OkHslH, OkHslL в пределах точности преобразования. При этом весь RGBA ограничивается 0…1: даже запись только OkHslS может изменить ранее выходившую за диапазон альфу. Не используйте для сохранения HDR-диапазона.

public int R8 { get; set; }

Чтение: (int)Math.Round(R * 255), середины округляются к чётному. Запись: R = value / 255f. Это int, не byte; ограничения 0…255 нет: запись 510 даёт компоненту 2. Для обычного 8-битного цвета используйте допустимый диапазон и конечные значения.

public float S { get; set; }

Насыщенность HSV: (max(R,G,B) − min(R,G,B)) / max(R,G,B), либо 0 при нулевом максимуме. Для RGB в 0…1 обычно 0…1. Запись пересоздаёт RGB через FromHsv(H, value, V, A), сохраняя альфу; значение не ограничивается.

public float V { get; set; }

Значение HSV: max(R, G, B). Не является Luminance и не ограничено 1: RGB = (2, 1, 0) даёт V = 2. Запись пересоздаёт RGB через FromHsv(H, S, value, A), сохраняя альфу; значение не ограничивается.

public Color Blend(Color over);

Накладывает передний цвет over на текущий цвет-фон с учётом прямой, не предумноженной альфы. Для альфы в 0…1 результат A = Aфон * (1 − Aпередний) + Aпередний; RGB нормируется на итоговую A. При итоговой A = 0 возвращает (0, 0, 0, 0).

Порядок важен: background.Blend(foreground). Метод считает в переданных числах RGB, не переводит sRGB в linear и не ограничивает каналы. Для смешивания sRGB-входов в линейном пространстве:

using Reckfell;

public static class SrgbColorOperations
{
    // Inputs: sRGB RGB values and straight alpha, all finite and in 0..1.
    // Output: sRGB RGB values and straight alpha.
    public static Color Composite(Color background, Color foreground)
    {
        Color backgroundLinear = background.SrgbToLinear();
        Color foregroundLinear = foreground.SrgbToLinear();
        return backgroundLinear.Blend(foregroundLinear).LinearToSrgb();
    }
}

public Color Clamp(Color? min = default, Color? max = default);

Возвращает копию с ограничением каждой RGBA-компоненты через Mathf.Clamp. По умолчанию min = (0, 0, 0, 0), max = (1, 1, 1, 1). Границы задаются отдельно для каждого канала; min выше max вызывает ArgumentException. Не является тональным отображением HDR и не исправляет NaN.

public static Color Color8(byte r8, byte g8, byte b8, byte a8 = 255);

Создаёт RGBA из четырёх байтов, деля каждый на 255. Отсутствующий a8 равен 255: цвет непрозрачный. Не выполняет преобразование sRGB/linear.

public Color Darkened(float amount);

Затемняет RGB по формуле RGB * (1 − amount), сохраняя A. При amount = 0 цвет прежний; при 1 RGB становится чёрным. amount не ограничивается: значения вне 0…1 дают экстраполяцию. Метод не преобразует цветовое пространство.

public bool Equals(Color other);

Сравнивает все четыре RGBA-компоненты точно, через == для float. Для результата вычислений с допуском используйте IsEqualApprox.

public override bool Equals(object? obj);

Возвращает true, только если obj — упакованная структура Color с точно равными RGBA-компонентами. Для null и объектов других типов возвращает false.

public static Color FromHsv(float hue, float saturation, float value, float alpha = 1f);

Создаёт RGB из HSV. Оттенок hue измеряется в оборотах, не градусах: 0 — красный, 1/3 — зелёный, 2/3 — синий. При saturation = 0 RGB = (value, value, value). Альфа по умолчанию 1. Значения saturation, value и alpha не ограничиваются.

Передавайте конечный hue в 0…1. Положительные обороты повторяются, но отрицательный hue не нормализуется корректно: например, −0.1 может дать отрицательный RGB-канал. Для интерфейса выбора цвета с градусами и явной политикой S/V/A в 0…1:

using System;
using Reckfell;

public static class PaletteColor
{
    // UI palette policy: hue in degrees; finite S, V and A in 0..1.
    public static bool TryFromHsvDegrees(float degrees, float saturation,
        float value, float alpha, out Color color)
    {
        color = default;
        if (!float.IsFinite(degrees) || !InUnitRange(saturation)
            || !InUnitRange(value) || !InUnitRange(alpha)) return false;
        float hue = degrees / 360f;
        hue -= MathF.Floor(hue);
        color = Color.FromHsv(hue, saturation, value, alpha);
        return true;
    }

    private static bool InUnitRange(float value) =>
        float.IsFinite(value) && value >= 0f && value <= 1f;
}

public static Color FromHtml(ReadOnlySpan<char> rgba);

Разбирает RGB, RGBA, RRGGBB или RRGGBBAA с необязательным #. Короткие каналы делятся на 15, длинные — на 255; отсутствующая альфа равна 1. Не преобразует цветовое пространство.

Важно: сначала проверяйте HtmlIsValid. Пустой ввод возвращает непрозрачный чёрный, хотя проверку не проходит. Неверная длина вызывает ArgumentOutOfRangeException, но отдельные неверные символы могут пройти разбор: например, 1g0000 принимается текущим C# SDK.

using System;
using Reckfell;

public static class HtmlColorInput
{
    // Exact hexadecimal format only: no names, spaces or CSS functions.
    public static bool TryParse(ReadOnlySpan<char> text, out Color color)
    {
        color = default;
        if (!Color.HtmlIsValid(text)) return false;
        color = Color.FromHtml(text);
        return true;
    }
}

public static Color FromOkHsl(float hue, float saturation, float lightness, float alpha = 1f);

Преобразует OKHSL в sRGB через нативный код движка. Это другая модель, чем HSV: используйте OkHslH, OkHslS и OkHslL для обратного чтения, а не H, S и V. Входные координаты обычно 0…1, hue — в оборотах. lightness = 0 даёт чёрный, 1 — белый.

Результат ограничивается 0…1 по всем четырём RGBA-компонентам, включая alpha. Это отличается от FromHsv. Для последующих вычислений в линейном пространстве вызовите SrgbToLinear(); для HDR без потери диапазона этот конструктор не подходит.

public static Color FromRgbe9995(uint rgbe);

Декодирует упакованный HDR-формат RGBE9995: биты 0…8 — R, 9…17 — G, 18…26 — B, 27…31 — общая экспонента E. Каждый RGB-результат равен своей 9-битной мантиссе * 2^(E − 24). Альфа всегда 1: в формате нет канала A.

Не путайте с 0xRRGGBBAA из Color(uint). Значения RGB могут быть выше 1; метод не выполняет тональное отображение или sRGB/linear-преобразование. Нулевое число даёт непрозрачный чёрный.

public static Color FromString(string str, Color @default);

Сначала проверяет HTML-код через HtmlIsValid, иначе ищет нормализованное имя из Colors. Если цвет не найден, возвращает default без изменения. Пустая строка тоже возвращает резервный цвет. Подходит для ввода с разрешёнными именами; для строго hex-ввода используйте HtmlIsValid и FromHtml.

public override int GetHashCode();

Вычисляет HashCode.Combine(R, G, B, A). Используется с точным Equals, а не IsEqualApprox; численно близкие цвета не обязаны иметь один хеш. Не сохраняйте это значение как постоянный ID цвета между запусками.

public static bool HtmlIsValid(ReadOnlySpan<char> color);

Проверяет точный hex-формат: 3/4/6/8 цифр, необязательный начальный #, регистр не важен. Пустая строка, пробелы, имена цветов и CSS-функции не принимаются. Вызывайте перед FromHtml для недоверенного ввода: сам FromHtml не является строгой проверкой всех символов.

public Color Inverted();

Возвращает (1 − R, 1 − G, 1 − B, A). Сохраняет альфу; унарный оператор -color, напротив, возвращает 1 − A в альфе. Компоненты не ограничиваются.

public bool IsEqualApprox(Color other);

Сравнивает каждую RGBA-компоненту через Mathf.IsEqualApprox. Все четыре сравнения должны пройти, включая альфу. Это численный допуск, а не оценка визуального сходства; цвета в разных кодировках RGB сначала приведите к одной.

public Color Lerp(Color to, float weight);

Покомпонентно вычисляет RGBA + (to − RGBA) * weight. При weight = 0 возвращает начальный цвет, при 1 — to; вне 0…1 экстраполирует. Интерполирует и альфу. Не накладывает один слой на другой, не предумножает RGB и не переводит sRGB в linear. Для перехода между sRGB-цветами в линейном пространстве преобразуйте оба входа SrgbToLinear(), затем результат LinearToSrgb().

public Color Lightened(float amount);

Осветляет RGB по формуле RGB + (1 − RGB) * amount, сохраняя A. При amount = 0 цвет прежний; при 1 RGB становится белым. amount не ограничивается: значения вне 0…1 дают экстраполяцию. Метод не преобразует цветовое пространство.

public Color LinearToSrgb();

Преобразует RGB из linear в sRGB поканальной передаточной функцией sRGB; A сохраняется. Вызывающий код должен знать кодировку входа: Color не хранит её метку. Метод не ограничивает HDR-значения и не делает тональное отображение. Повторное преобразование уже преобразованного цвета даст неверный результат. Исходная структура не меняется.

public Color SrgbToLinear();

Преобразует RGB из sRGB в linear поканальной передаточной функцией sRGB; A сохраняется. Вызывающий код должен знать кодировку входа: Color не хранит её метку. Метод не ограничивает HDR-значения и не делает тональное отображение. Повторное преобразование уже преобразованного цвета даст неверный результат. Исходная структура не меняется.

public uint ToAbgr32();

Упаковывает каналы в uint 0xAABBGGRR, по 8 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 255 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public ulong ToAbgr64();

Упаковывает каналы в ulong 0xAAAABBBBGGGGRRRR, по 16 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 65535 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public uint ToArgb32();

Упаковывает каналы в uint 0xAARRGGBB, по 8 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 255 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public ulong ToArgb64();

Упаковывает каналы в ulong 0xAAAARRRRGGGGBBBB, по 16 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 65535 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public void ToHsv(out float hue, out float saturation, out float value);

Вычисляет HSV из текущих RGB и записывает три out-параметра; не меняет цвет и не возвращает альфу. Для обычного RGB в 0…1 оттенок и насыщенность тоже в 0…1. Серый цвет получает hue = 0 и saturation = 0; чёрный также value = 0. Для HDR value может быть выше 1. Расчёт идёт по хранимым RGB без преобразования sRGB/linear.

public string ToHtml(bool includeAlpha = true);

Возвращает строчные hex-цифры без #: RRGGBBAA по умолчанию, RRGGBB при includeAlpha = false. Конечные значения каналов ограничиваются 0…1 и округляются до байта. Например, new Color(1, 1, 1, 0.5f).ToHtml() даёт "ffffff80". Это потеря точности до 8 бит на канал, без преобразования цветового пространства.

public uint ToRgba32();

Упаковывает каналы в uint 0xRRGGBBAA, по 8 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 255 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public ulong ToRgba64();

Упаковывает каналы в ulong 0xRRRRGGGGBBBBAAAA, по 16 бит на канал: порядок указан от старших битов к младшим. Умножает каждый канал на 65535 и округляет Math.Round (середины к чётному). Передавайте конечные значения 0…1; метод не ограничивает диапазон. Для обычного цвета вне диапазона сначала используйте Clamp(); для HDR сначала выберите отображение яркости. Формат числа не задаёт порядок байтов памяти и не преобразует sRGB/linear.

public override string ToString();

Возвращает текст (R, G, B, A) с CultureInfo.InvariantCulture: десятичная точка не зависит от языка системы. Перегрузка без аргумента использует числовой формат по умолчанию. Для HTML-кода используйте ToHtml(), не ToString().

public string ToString(string? format);

Возвращает текст (R, G, B, A) с CultureInfo.InvariantCulture: десятичная точка не зависит от языка системы. format передаётся каждой float-компоненте; например F2 даёт два знака после точки. Для HTML-кода используйте ToHtml(), не ToString().

public static Color operator +(Color left, Color right);

Вычисляет + для каждой RGBA-компоненты с соответствующей компонентой второго цвета. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Это арифметика каналов; для наложения прозрачных слоёв используйте Blend.

public static Color operator /(Color left, Color right);

Вычисляет / для каждой RGBA-компоненты с соответствующей компонентой второго цвета. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Нулевой делитель float может дать Infinity или NaN; проверяйте делитель до вычисления.

public static Color operator /(Color color, float scale);

Вычисляет / для каждой RGBA-компоненты с одним scale. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Нулевой делитель float может дать Infinity или NaN; проверяйте делитель до вычисления.

public static bool operator ==(Color left, Color right);

Точное сравнение четырёх float-компонент RGBA оператором ==. После вычислений возможна погрешность: для приблизительного сравнения используйте IsEqualApprox. Не сравнивает видимый результат после наложения на фон.

public static bool operator >(Color left, Color right);

Лексикографически сравнивает конечные RGBA оператором >: сначала R, при равенстве G, затем B и A. Это порядок для сортировки, а не сравнение яркости или прозрачности. Не используйте NaN-компоненты для упорядочивания.

public static bool operator >=(Color left, Color right);

Лексикографически сравнивает конечные RGBA оператором >=: сначала R, при равенстве G, затем B и A. Это порядок для сортировки, а не сравнение яркости или прозрачности. Не используйте NaN-компоненты для упорядочивания.

public static bool operator !=(Color left, Color right);

Точное сравнение четырёх float-компонент RGBA оператором !=. После вычислений возможна погрешность: для приблизительного сравнения используйте IsEqualApprox. Не сравнивает видимый результат после наложения на фон.

public static bool operator <(Color left, Color right);

Лексикографически сравнивает конечные RGBA оператором <: сначала R, при равенстве G, затем B и A. Это порядок для сортировки, а не сравнение яркости или прозрачности. Не используйте NaN-компоненты для упорядочивания.

public static bool operator <=(Color left, Color right);

Лексикографически сравнивает конечные RGBA оператором <=: сначала R, при равенстве G, затем B и A. Это порядок для сортировки, а не сравнение яркости или прозрачности. Не используйте NaN-компоненты для упорядочивания.

public static Color operator *(Color left, Color right);

Вычисляет * для каждой RGBA-компоненты с соответствующей компонентой второго цвета. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Это арифметика каналов; для наложения прозрачных слоёв используйте Blend.

public static Color operator *(Color color, float scale);

Вычисляет * для каждой RGBA-компоненты с одним scale. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Это арифметика каналов; для наложения прозрачных слоёв используйте Blend.

public static Color operator *(float scale, Color color);

Вычисляет * для каждой RGBA-компоненты с одним scale. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Это арифметика каналов; для наложения прозрачных слоёв используйте Blend.

public static Color operator -(Color left, Color right);

Вычисляет − для каждой RGBA-компоненты с соответствующей компонентой второго цвета. Альфа тоже участвует. Не ограничивает каналы и не преобразует цветовое пространство. Это арифметика каналов; для наложения прозрачных слоёв используйте Blend.

public static Color operator -(Color color);

Возвращает (1 − R, 1 − G, 1 − B, 1 − A). Это инверсия относительно белого, а не арифметическое изменение знака. Альфа тоже инвертируется. Чтобы сохранить альфу, используйте Inverted().

public static Color operator +(Color color);

Возвращает цвет без изменений; не ограничивает компоненты.

public float A;

Альфа как float без ограничения диапазона; обычно 0 — полностью прозрачно, 1 — непрозрачно. Реальный эффект зависит от материала и режима смешивания. Изменение A само по себе не умножает RGB на альфу.

public float B;

Компонента B как float без ограничения диапазона. Обычно 0…1; значения выше 1 можно хранить для HDR-вычислений. Структура не помечает канал как sRGB или linear: это определяет код, использующий цвет.

public float G;

Компонента G как float без ограничения диапазона. Обычно 0…1; значения выше 1 можно хранить для HDR-вычислений. Структура не помечает канал как sRGB или linear: это определяет код, использующий цвет.

public float R;

Компонента R как float без ограничения диапазона. Обычно 0…1; значения выше 1 можно хранить для HDR-вычислений. Структура не помечает канал как sRGB или linear: это определяет код, использующий цвет.