Vector3I

public Vector3I(int x, int y, int z);

Записывает x, y, z в соответствующие int-компоненты без округления, нормализации или ограничения диапазона. default(Vector3I) содержит нули. Это структура: присваивание копирует все компоненты.

public static Vector3I Back { get; }

(0, 0, 1). Назад: положительный Z. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I Down { get; }

(0, -1, 0). Вниз: отрицательный Y. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I Forward { get; }

(0, 0, -1). Вперёд: отрицательный Z. Возвращается копия значения; её изменение не меняет константу.

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

Индексы компонент: 0 = X, 1 = Y, 2 = Z. Getter и setter вне диапазона 0..2 выбрасывают ArgumentOutOfRangeException. Меняется эта переменная структуры; ранее присвоенная копия не меняется.

public static Vector3I Left { get; }

(-1, 0, 0). Отрицательный X. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I MaxValue { get; }

(int.MaxValue, int.MaxValue, int.MaxValue). Конечные максимальные int, а не бесконечность; арифметика может переполниться. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I MinValue { get; }

(int.MinValue, int.MinValue, int.MinValue). Конечные минимальные int, а не отрицательная бесконечность. Abs() выбрасывает OverflowException. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I One { get; }

(1, 1, 1). Все компоненты равны 1; это не единичная длина. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I Right { get; }

(1, 0, 0). Положительный X. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I Up { get; }

(0, 1, 0). Вверх: положительный Y. Возвращается копия значения; её изменение не меняет константу.

public static Vector3I Zero { get; }

(0, 0, 0). Нулевой вектор, равный default(Vector3I). Возвращается копия значения; её изменение не меняет константу.

public Vector3I Abs();

Возвращает новую структуру с Math.Abs для каждой компоненты; исходное значение не меняется. Для int.MinValue положительный результат не помещается в int, поэтому выбрасывается OverflowException.

public Vector3I Clamp(Vector3I min, Vector3I max);

Возвращает копию с покомпонентным ограничением включительными границами. У каждой оси свои min и max. Если любая нижняя граница выше верхней, выбрасывается ArgumentException; границы не переставляются.

public Vector3I Clamp(int min, int max);

Возвращает копию с покомпонентным ограничением включительными границами. Одни min и max применяются ко всем осям. Если любая нижняя граница выше верхней, выбрасывается ArgumentException; границы не переставляются.

public void Deconstruct(out int x, out int y, out int z);

Копирует компоненты в выходные аргументы в порядке X, Y, Z. Позволяет записать var (x, y, z) = vector; исходный вектор не меняется.

public int DistanceSquaredTo(Vector3I to);

Вычисляет (to - this).LengthSquared() в int. Переполнение возможно уже при вычитании, затем при возведении в квадрат и сложении; результат может быть отрицательным или ошибочно малым. Не используйте для больших координат без проверки диапазона. Для широкого диапазона переводите компоненты в double до вычитания — пример приведён у DistanceTo.

public float DistanceTo(Vector3I to);

Вычисляет (to - this).Length(). Float-результат не защищает от переполнения int при вычитании и возведении в квадрат. От (int.MinValue, 0, 0) до (int.MaxValue, 0, 0) установленный SDK возвращает 1 вместо 4294967295.

WideDistance переводит каждую компоненту в double до вычитания. CellAt использует Floor: (-1, 33, -17) при шаге 16 даёт (-1, 2, -2); неположительный шаг и непредставимые координаты отвергаются.

using System;
using Reckfell;

public static class IntegerSpaceExamples
{
    public static Vector3I CellAt(Vector3 position, int cellSize)
    {
        if (cellSize <= 0) throw new ArgumentOutOfRangeException(nameof(cellSize));
        Vector3 cell = (position / cellSize).Floor();
        for (int axis = 0; axis < 3; axis++)
            if (!float.IsFinite(cell[axis]) || (double)cell[axis] < int.MinValue || (double)cell[axis] > int.MaxValue)
                throw new ArgumentOutOfRangeException(nameof(position));
        return (Vector3I)cell;
    }

    public static double WideDistance(Vector3I from, Vector3I to)
    {
        double dx = (double)to.X - from.X;
        double dy = (double)to.Y - from.Y;
        double dz = (double)to.Z - from.Z;
        return Math.Sqrt(dx * dx + dy * dy + dz * dz);
    }

    public static double WideDistance(Vector4I from, Vector4I to)
    {
        double dx = (double)to.X - from.X;
        double dy = (double)to.Y - from.Y;
        double dz = (double)to.Z - from.Z;
        double dw = (double)to.W - from.W;
        return Math.Sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
    }
}

public bool Equals(Vector3I other);

Точно сравнивает X, Y, Z. Приближённого сравнения и сравнения длин нет.

public override bool Equals(object? obj);

Точно сравнивает X, Y, Z. object должен содержать Vector3I: Vector3 с теми же координатами, null и другие типы дают false.

public override int GetHashCode();

Использует HashCode.Combine(X, Y, Z). Равные векторы имеют одинаковый хеш, но совпадение хеша не доказывает равенство. Подходит для ключей Dictionary<Vector3I, T>; не сохраняйте хеш как постоянный идентификатор между запусками.

public float Length();

Вычисляет XX + YY + Z*Z в int, затем извлекает float-корень. Переполнение возможно в квадратах и сумме: (50000, 0, 0) даёт NaN, а (65536, 0, 0) — 0. Для широкого диапазона переводите компоненты в double до умножения.

public int LengthSquared();

Вычисляет XX + YY + Z*Z в int, без корня. Переполнение возможно в квадратах и сумме: (50000, 0, 0) даёт отрицательный квадрат длины, а (65536, 0, 0) — 0. Для широкого диапазона переводите компоненты в double до умножения.

public Vector3I Max(Vector3I with);

Большая из двух величин выбирается отдельно для X, Y, Z; возвращается копия. Аргумент задаёт отдельные значения по осям. Это не выбор одного целого вектора по операторам < или >.

public Vector3I Max(int with);

Большая из двух величин выбирается отдельно для X, Y, Z; возвращается копия. Одно значение сравнивается с обеими компонентами. Это не выбор одного целого вектора по операторам < или >.

public Vector3I.Axis MaxAxisIndex();

Большая знаковая компонента определяет ось; абсолютные величины не сравниваются. При равенстве выбирается первая ось в порядке X, Y, Z. У равных компонент результат Axis.X.

public Vector3I Min(Vector3I with);

Меньшая из двух величин выбирается отдельно для X, Y, Z; возвращается копия. Аргумент задаёт отдельные значения по осям. Это не выбор одного целого вектора по операторам < или >.

public Vector3I Min(int with);

Меньшая из двух величин выбирается отдельно для X, Y, Z; возвращается копия. Одно значение сравнивается с обеими компонентами. Это не выбор одного целого вектора по операторам < или >.

public Vector3I.Axis MinAxisIndex();

Меньшая знаковая компонента определяет ось; абсолютные величины не сравниваются. При равенстве выбирается последняя ось в порядке X, Y, Z. У равных компонент результат Axis.Z.

public Vector3I Sign();

Возвращает новую структуру: отрицательная компонента становится -1, нулевая — 0, положительная — 1. int.MinValue даёт -1 без взятия абсолютной величины. Это не нормализация длины: (1, 1, 1) остаётся (1, 1, 1).

public Vector3I Snapped(Vector3I step);

Привязывает каждую компоненту к шагу через double-формулу floor(value / step + 0.5) * step с последующим приведением к int. Положительный шаг округляет половины к большему значению: (6, -6, 2).Snapped(4) даёт (8, -4, 4). Нулевой шаг сохраняет компоненту; отрицательный меняет правило половин, поэтому используйте положительный шаг. Результат должен помещаться в int; ограничение диапазона не выполняется.

public Vector3I Snapped(int step);

Привязывает каждую компоненту к шагу через double-формулу floor(value / step + 0.5) * step с последующим приведением к int. Положительный шаг округляет половины к большему значению: (6, -6, 2).Snapped(4) даёт (8, -4, 4). Нулевой шаг сохраняет компоненту; отрицательный меняет правило половин, поэтому используйте положительный шаг. Результат должен помещаться в int; ограничение диапазона не выполняется.

public override string ToString();

Использует CultureInfo.InvariantCulture независимо от текущей культуры; вектор (3, -4, 2) возвращает "(3, -4, 2)". Эквивалентно ToString(null).

public string ToString(string? format);

Использует CultureInfo.InvariantCulture независимо от текущей культуры; вектор (3, -4, 2) возвращает "(3, -4, 2)". format применяется отдельно к каждому int: "D4" даёт "(0003, -0004, 0002)". Неверный формат вызывает FormatException.

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

Возвращает (left.X + right.X, left.Y + right.Y, left.Z + right.Z) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор.

public static Vector3I operator /(Vector3I vec, Vector3I divisorv);

Целочисленно делит каждую компоненту с усечением к нулю: (-7, 7, 0) / (2, 2, 2) даёт (-3, 3, 0). Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Делители заданы отдельно по осям.

public static Vector3I operator /(Vector3I vec, int divisor);

Целочисленно делит каждую компоненту с усечением к нулю: (-7, 7, 0) / 2 даёт (-3, 3, 0). Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Один делитель применяется ко всем осям.

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

Точно сравнивает все целочисленные компоненты. Значения не сравниваются по длине; приближённый допуск не используется.

public static explicit operator Vector3I(Vector3 value);

Приводит каждую компоненту Vector3 к int с усечением к нулю: (-1.9, 1.9, -2.9) даёт (-1, 1, -2). Для отрицательных координат клеток сначала используйте Floor. До приведения проверяйте конечность и диапазон int; переносимый результат для NaN, Infinity и выхода за диапазон не гарантируется.

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

Лексикографическое сравнение в порядке X, Y, Z: следующая компонента проверяется только при равенстве предыдущих. Это порядок сортировки, а не покомпонентная проверка границ и не сравнение длин. (1, 100, 0) < (2, -100, 0) — true, несмотря на больший Y слева. Для проверки области сравнивайте оси явно.

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

Лексикографическое сравнение в порядке X, Y, Z: следующая компонента проверяется только при равенстве предыдущих. Это порядок сортировки, а не покомпонентная проверка границ и не сравнение длин. (1, 100, 0) < (2, -100, 0) — true, несмотря на больший Y слева. Для проверки области сравнивайте оси явно.

public static implicit operator Vector3(Vector3I value);

Преобразует каждую int-компоненту во float-компоненту Vector3 установленного SDK. Большие целые могут потерять точность: 16777217 превращается в 16777216. Для точной арифметики сетки сохраняйте Vector3I до этапа отображения.

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

Отрицает ==. Значения не сравниваются по длине; приближённый допуск не используется.

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

Лексикографическое сравнение в порядке X, Y, Z: следующая компонента проверяется только при равенстве предыдущих. Это порядок сортировки, а не покомпонентная проверка границ и не сравнение длин. (1, 100, 0) < (2, -100, 0) — true, несмотря на больший Y слева. Для проверки области сравнивайте оси явно.

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

Лексикографическое сравнение в порядке X, Y, Z: следующая компонента проверяется только при равенстве предыдущих. Это порядок сортировки, а не покомпонентная проверка границ и не сравнение длин. (1, 100, 0) < (2, -100, 0) — true, несмотря на больший Y слева. Для проверки области сравнивайте оси явно.

public static Vector3I operator %(Vector3I vec, Vector3I divisorv);

Вычисляет остатки C# от усечённого деления: (10, -20, 0) % (7, 7, 7) даёт (3, -6, 0). Это не положительное циклическое оборачивание; для него используйте Mathf.PosMod с положительным модулем. Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Делители заданы отдельно по осям.

public static Vector3I operator %(Vector3I vec, int divisor);

Вычисляет остатки C# от усечённого деления: (10, -20, 0) % 7 даёт (3, -6, 0). Это не положительное циклическое оборачивание; для него используйте Mathf.PosMod с положительным модулем. Нулевой делитель вызывает DivideByZeroException. Сочетание int.MinValue и -1 для соответствующей компоненты в установленном SDK вызывает OverflowException. Один делитель применяется ко всем осям.

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

Возвращает (left.X * right.X, left.Y * right.Y, left.Z * right.Z) как новую структуру. Для int используется один множитель всех осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор.

public static Vector3I operator *(Vector3I vec, int scale);

Возвращает (vec.X * scale, vec.Y * scale, vec.Z * scale) как новую структуру. Для int используется один множитель всех осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор.

public static Vector3I operator *(int scale, Vector3I vec);

Возвращает (vec.X * scale, vec.Y * scale, vec.Z * scale) как новую структуру. Для int используется один множитель всех осей; два вектора умножаются покомпонентно, не как скалярное произведение. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор.

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

Возвращает (left.X - right.X, left.Y - right.Y, left.Z - right.Z) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор.

public static Vector3I operator -(Vector3I vec);

Возвращает (-X, -Y, -Z) как новую структуру. В установленном SDK переполнение int оборачивается без насыщения; checked вокруг вызова не меняет уже скомпилированный оператор. Для -int.MinValue остаётся int.MinValue.

public static Vector3I operator +(Vector3I vec);

Возвращает (X, Y, Z) как новую структуру. Унарный плюс не меняет значение.

public int X;

Изменяемая знаковая 32-битная компонента X, также доступная через [0]. Присваивание не меняет другие компоненты и не ограничивает диапазон.

public int Y;

Изменяемая знаковая 32-битная компонента Y, также доступная через [1]. Присваивание не меняет другие компоненты и не ограничивает диапазон. В 3D положительный Y направлен вверх.

public int Z;

Изменяемая знаковая 32-битная компонента Z, также доступная через [2]. Присваивание не меняет другие компоненты и не ограничивает диапазон. Forward направлен по отрицательному Z.