Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

AABB

Ограничивающая рамка, выровненная по трехмерным осям.

Описание

Встроенный тип Variant AABB представляет собой ограничивающий прямоугольник, выровненный по осям, в трёхмерном пространстве. Он определяется параметрами position и size, которые равны Vector3. Он часто используется для быстрых тестов на перекрытие (см. intersects()). Хотя сам AABB выровнен по осям, его можно комбинировать с Transform3D для представления повёрнутого или наклонённого ограничивающего прямоугольника.

Он использует координаты с плавающей точкой. 2D аналогом AABB является Rect2. Версии AABB с целочисленными координатами не существует.

Примечание: Отрицательные значения size не поддерживаются. При отрицательном размере большинство методов AABB работают некорректно. Используйте abs() для получения эквивалентного AABB с неотрицательным размером.

Примечание: В булевом контексте AABB вычисляется как false, если и position, и size равны нулю (равны Vector3.ZERO). В противном случае он всегда вычисляется как true.

Примечание

Существуют заметные различия при использовании данного API с C#. Подробнее см. API различия C# и GDScript.

Обучающие материалы

Свойства

Vector3	end	`Vector3(0, 0, 0)`
Vector3	position	`Vector3(0, 0, 0)`
Vector3	size	`Vector3(0, 0, 0)`

Конструкторы

AABB	AABB()
AABB	AABB(from: AABB)
AABB	AABB(position: Vector3, size: Vector3)

Методы

AABB	abs() const
bool	encloses(with: AABB) const
AABB	expand(to_point: Vector3) const
Vector3	get_center() const
Vector3	get_endpoint(idx: int) const
Vector3	get_longest_axis() const
int	get_longest_axis_index() const
float	get_longest_axis_size() const
Vector3	get_shortest_axis() const
int	get_shortest_axis_index() const
float	get_shortest_axis_size() const
Vector3	get_support(direction: Vector3) const
float	get_volume() const
AABB	grow(by: float) const
bool	has_point(point: Vector3) const
bool	has_surface() const
bool	has_volume() const
AABB	intersection(with: AABB) const
bool	intersects(with: AABB) const
bool	intersects_plane(plane: Plane) const
Variant	intersects_ray(from: Vector3, dir: Vector3) const
Variant	intersects_segment(from: Vector3, to: Vector3) const
bool	is_equal_approx(aabb: AABB) const
bool	is_finite() const
AABB	merge(with: AABB) const

Операторы

bool	operator !=(right: AABB)
AABB	operator *(right: Transform3D)
bool	operator ==(right: AABB)

Описания свойств

Vector3 end = Vector3(0, 0, 0) 🔗

Конечная точка. Обычно это угол сверху справа и сзади ограничивающего прямоугольника, и эквивалентно position + size. Установка этой точки влияет на size.

Vector3 position = Vector3(0, 0, 0) 🔗

Начальная точка. Обычно это нижний левый угол спереди ограничивающей рамки.

Vector3 size = Vector3(0, 0, 0) 🔗

Ширина, высота и глубина ограничивающего прямоугольника, начиная с position. Установка этого значения также влияет на точку end.

Примечание: Рекомендуется устанавливать ширину, высоту и глубину на неотрицательные значения. Это связано с тем, что большинство методов в Godot предполагают, что position — это нижний левый передний угол, а end — это верхний правый задний угол. Чтобы получить эквивалентный ограничивающий прямоугольник с неотрицательным размером, используйте abs().

Описания конструктора

AABB AABB() 🔗

Создает AABB с его position и size, установленными на Vector3.ZERO.

AABB AABB(from: AABB)

Создает AABB как копию заданного AABB.

AABB AABB(position: Vector3, size: Vector3)

Создает AABB по position и size.

Описания метода

AABB abs() const 🔗

Возвращает эквивалент AABB для данного ограничивающего прямоугольника, ширина, высота и глубина которого изменены так, чтобы они были неотрицательными значениями.

var box = AABB(Vector3(5, 0, 5), Vector3(-20, -10, -5))
var absolute = box.abs()
print(absolute.position) # Выводит (-15.0, -10.0, 0.0)
print(absolute.size)     # Выводит (20.0, 10.0, 5.0)

var box = new Aabb(new Vector3(5, 0, 5), new Vector3(-20, -10, -5));
var absolute = box.Abs();
GD.Print(absolute.Position); // Выводит (-15, -10, 0)
GD.Print(absolute.Size);     // Выводит (20, 10, 5)

Примечание: Рекомендуется использовать этот метод, когда size отрицательный, так как большинство других методов в Godot предполагают, что компоненты size больше, чем 0.

bool encloses(with: AABB) const 🔗

Возвращает true, если этот ограничивающий прямоугольник полностью охватывает прямоугольник with. Края обоих прямоугольников включены.

var a = AABB(Vector3(0, 0, 0), Vector3(4, 4, 4))
var b = AABB(Vector3(1, 1, 1), Vector3(3, 3, 3))
var c = AABB(Vector3(2, 2, 2), Vector3(8, 8, 8))

print(a.encloses(a)) # Выводит true
print(a.encloses(b)) # Выводит true
print(a.encloses(c)) # Выводит false

var a = new Aabb(new Vector3(0, 0, 0), new Vector3(4, 4, 4));
var b = new Aabb(new Vector3(1, 1, 1), new Vector3(3, 3, 3));
var c = new Aabb(new Vector3(2, 2, 2), new Vector3(8, 8, 8));

GD.Print(a.Encloses(a)); // Выводит True
GD.Print(a.Encloses(b)); // Выводит True
GD.Print(a.Encloses(c)); // Выводит False

AABB expand(to_point: Vector3) const 🔗

Возвращает копию этого ограничивающего прямоугольника, расширенного для выравнивания краев с заданным to_point, если это необходимо.

var box = AABB(Vector3(0, 0, 0), Vector3(5, 2, 5))

box = box.expand(Vector3(10, 0, 0))
print(box.position) # Выводит (0.0, 0.0, 0.0)
print(box.size)     # Выводит (10.0, 2.0, 5.0)

box = box.expand(Vector3(-5, 0, 5))
print(box.position) # Выводит (-5.0, 0.0, 0.0)
print(box.size)     # Выводит (15.0, 2.0, 5.0)

var box = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 5));

box = box.Expand(new Vector3(10, 0, 0));
GD.Print(box.Position); // Выводит (0, 0, 0)
GD.Print(box.Size);     // Выводит (10, 2, 5)

box = box.Expand(new Vector3(-5, 0, 5));
GD.Print(box.Position); // Выводит  (-5, 0, 0)
GD.Print(box.Size);     // Выводит (15, 2, 5)

Vector3 get_center() const 🔗

Возвращает центральную точку ограничивающего прямоугольника. Это то же самое, что и position + (size / 2.0).

Vector3 get_endpoint(idx: int) const 🔗

Возвращает положение одной из 8 вершин, составляющих этот ограничивающий параллелепипед. Если idx равен 0, это то же самое, что и position, а если idx равен 7, это то же самое, что и end.

Vector3 get_longest_axis() const 🔗

Возвращает самую длинную нормализованную ось size этого ограничивающего прямоугольника в виде Vector3 (Vector3.RIGHT, Vector3.UP или Vector3.BACK).

var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))

print(box.get_longest_axis())       # Выводит (0.0, 0.0, 1.0)
print(box.get_longest_axis_index()) # Выводит 2
print(box.get_longest_axis_size())  # Выводит 8.0

var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));

GD.Print(box.GetLongestAxis());      // Выводит (0, 0, 1)
GD.Print(box.GetLongestAxisIndex()); // Выводит Z
GD.Print(box.GetLongestAxisSize());  // Выводит 8

См. также get_longest_axis_index() и get_longest_axis_size().

int get_longest_axis_index() const 🔗

Возвращает индекс самой длинной оси size этого ограничивающего прямоугольника (см. Vector3.AXIS_X, Vector3.AXIS_Y и Vector3.AXIS_Z).

Пример см. в get_longest_axis().

float get_longest_axis_size() const 🔗

Возвращает самое длинное измерение size этого ограничивающего прямоугольника.

Пример см. в get_longest_axis().

Vector3 get_shortest_axis() const 🔗

Возвращает самую короткую нормализованную ось size этого ограничивающего прямоугольника в виде Vector3 (Vector3.RIGHT, Vector3.UP или Vector3.BACK).

var box = AABB(Vector3(0, 0, 0), Vector3(2, 4, 8))

print(box.get_shortest_axis())       # Выводит (1.0, 0.0, 0.0)
print(box.get_shortest_axis_index()) # Выводит 0
print(box.get_shortest_axis_size())  # Выводит 2.0

var box = new Aabb(new Vector3(0, 0, 0), new Vector3(2, 4, 8));

GD.Print(box.GetShortestAxis());      // Выводит (1, 0, 0)
GD.Print(box.GetShortestAxisIndex()); // Выводит X
GD.Print(box.GetShortestAxisSize());  // Выводит 2

См. также get_shortest_axis_index() и get_shortest_axis_size().

int get_shortest_axis_index() const 🔗

Возвращает индекс самой короткой оси size этого ограничивающего прямоугольника (см. Vector3.AXIS_X, Vector3.AXIS_Y и Vector3.AXIS_Z).

Пример см. в get_shortest_axis().

float get_shortest_axis_size() const 🔗

Возвращает наименьшее измерение size этого ограничивающего прямоугольника.

Пример см. в get_shortest_axis().

Vector3 get_support(direction: Vector3) const 🔗

Возвращает позицию вершины этого ограничивающего прямоугольника, которая находится дальше всего в заданном направлении. Эта точка обычно известна как опорная точка в алгоритмах обнаружения столкновений.

float get_volume() const 🔗

Возвращает объем ограничивающего прямоугольника. Это эквивалентно size.x * size.y * size.z. См. также has_volume().

AABB grow(by: float) const 🔗

Возвращает копию этого ограничивающего прямоугольника, расширенного со всех сторон на указанное значение by. Отрицательное значение вместо этого сжимает прямоугольник.

var a = AABB(Vector3(4, 4, 4), Vector3(8, 8, 8)).grow(4)
print(a.position) # Выводит (0.0, 0.0, 0.0)
print(a.size)     # Выводит (16.0, 16.0, 16.0)

var b = AABB(Vector3(0, 0, 0), Vector3(8, 4, 2)).grow(2)
print(b.position) # Выводит (-2.0, -2.0, -2.0)
print(b.size)     # Выводит (12.0, 8.0, 6.0)

var a = new Aabb(new Vector3(4, 4, 4), new Vector3(8, 8, 8)).Grow(4);
GD.Print(a.Position); // Выводит (0, 0, 0)
GD.Print(a.Size);     // Выводит (16, 16, 16)

var b = new Aabb(new Vector3(0, 0, 0), new Vector3(8, 4, 2)).Grow(2);
GD.Print(b.Position); // Выводит (-2, -2, -2)
GD.Print(b.Size);     // Выводит (12, 8, 6)

bool has_point(point: Vector3) const 🔗

Возвращает true, если ограничивающий прямоугольник содержит заданный point. По соглашению, точки точно на правой, верхней и передней сторонах не включены.

Примечание: Этот метод ненадежен для AABB с отрицательным size. Сначала используйте abs(), чтобы получить допустимый ограничивающий прямоугольник.

bool has_surface() const 🔗

Возвращает true, если этот ограничивающий прямоугольник имеет поверхность или длину, то есть хотя бы один компонент size больше, чем 0. В противном случае возвращает false.

bool has_volume() const 🔗

Возвращает true, если ширина, высота и глубина этого ограничивающего прямоугольника положительны. См. также get_volume().

AABB intersection(with: AABB) const 🔗

Возвращает пересечение между этим ограничивающим прямоугольником и with. Если прямоугольники не пересекаются, возвращает пустой AABB. Если прямоугольники пересекаются по краю, возвращает плоский AABB без объема (см. has_surface() и has_volume()).

var box1 = AABB(Vector3(0, 0, 0), Vector3(5, 2, 8))
var box2 = AABB(Vector3(2, 0, 2), Vector3(8, 4, 4))

var intersection = box1.intersection(box2)
print(intersection.position) # Выводит (2.0, 0.0, 2.0)
print(intersection.size)     # Выводит (3.0, 2.0, 4.0)

var box1 = new Aabb(new Vector3(0, 0, 0), new Vector3(5, 2, 8));
var box2 = new Aabb(new Vector3(2, 0, 2), new Vector3(8, 4, 4));

var intersection = box1.Intersection(box2);
GD.Print(intersection.Position); // Выводит (2, 0, 2)
GD.Print(intersection.Size);     // Выводит (3, 2, 4)

Примечание: Если вам нужно только узнать, пересекаются ли два ограничивающих прямоугольника, используйте вместо этого intersects().

bool intersects(with: AABB) const 🔗

Возвращает true, если этот ограничивающий прямоугольник перекрывается с прямоугольником with. Края обоих прямоугольников всегда исключаются.

bool intersects_plane(plane: Plane) const 🔗

Возвращает true, если этот ограничивающий прямоугольник находится по обе стороны заданной plane.

Variant intersects_ray(from: Vector3, dir: Vector3) const 🔗

Возвращает первую точку пересечения этого ограничивающего прямоугольника и заданного луча в виде Vector3. Если пересечения не происходит, возвращает null.

Луч начинается в from, смотрит в dir и простирается в бесконечность.

Variant intersects_segment(from: Vector3, to: Vector3) const 🔗

Возвращает первую точку пересечения этого ограничивающего прямоугольника и заданного сегмента в виде Vector3. Если пересечения не происходит, возвращает null.

Сегмент начинается в from и заканчивается в to.

bool is_equal_approx(aabb: AABB) const 🔗

Возвращает true, если этот ограничивающий прямоугольник и aabb приблизительно равны, вызывая Vector3.is_equal_approx() для position и size.

bool is_finite() const 🔗

Возвращает true, если значения этого ограничивающего прямоугольника конечны, вызывая Vector3.is_finite() для position и size.

AABB merge(with: AABB) const 🔗

Возвращает AABB, который охватывает как этот ограничивающий прямоугольник, так и with по краям. См. также encludes().

Описания оператора

bool operator !=(right: AABB) 🔗

Возвращает true, если position или size обоих ограничивающих рамок не равны.

Примечание: Из-за ошибок точности с плавающей точкой рассмотрите возможность использования is_equal_approx(), который более надежен.

AABB operator *(right: Transform3D) 🔗

Обратно преобразует (умножает) AABB на заданную матрицу преобразования Transform3D, при условии, что базис преобразования ортонормален (т. е. поворот/отражение хороши, масштабирование/перекос — нет).

aabb * transform эквивалентно transform.inverse() * aabb. См. Transform3D.inverse().

Для преобразования с помощью обратного аффинного преобразования (например, с масштабированием) вместо этого можно использовать transform.affine_inverse() * aabb. См. Transform3D.affine_inverse().

bool operator ==(right: AABB) 🔗

Возвращает true, если и position и size ограничивающих рамок в точности равны.

Примечание: Из-за ошибок точности с плавающей точкой рассмотрите возможность использования is_equal_approx(), который более надежен.