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.
Обучающие материалы
Свойства
|
||
|
||
|
Конструкторы
AABB() |
|
Методы
abs() const |
|
get_center() const |
|
get_endpoint(idx: int) const |
|
get_longest_axis() const |
|
get_longest_axis_index() const |
|
get_longest_axis_size() const |
|
get_shortest_axis() const |
|
get_shortest_axis_index() const |
|
get_shortest_axis_size() const |
|
get_support(direction: Vector3) const |
|
get_volume() const |
|
has_surface() const |
|
has_volume() const |
|
intersection(with: AABB) const |
|
intersects(with: AABB) const |
|
intersects_plane(plane: Plane) const |
|
intersects_ray(from: Vector3, dir: Vector3) const |
|
intersects_segment(from: Vector3, to: Vector3) const |
|
is_equal_approx(aabb: AABB) const |
|
is_finite() const |
|
Операторы
operator !=(right: AABB) |
|
operator *(right: Transform3D) |
|
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 с его position и size, установленными на Vector3.ZERO.
Создает AABB как копию заданного AABB.
AABB AABB(position: Vector3, size: Vector3)
Создает AABB по position и size.
Описания метода
Возвращает эквивалент 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)
Возвращает центральную точку ограничивающего прямоугольника. Это то же самое, что и 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 🔗
Возвращает позицию вершины этого ограничивающего прямоугольника, которая находится дальше всего в заданном направлении. Эта точка обычно известна как опорная точка в алгоритмах обнаружения столкновений.
Возвращает объем ограничивающего прямоугольника. Это эквивалентно size.x * size.y * size.z. См. также has_volume().
Возвращает копию этого ограничивающего прямоугольника, расширенного со всех сторон на указанное значение 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(), чтобы получить допустимый ограничивающий прямоугольник.
Возвращает true, если этот ограничивающий прямоугольник имеет поверхность или длину, то есть хотя бы один компонент size больше, чем 0. В противном случае возвращает false.
Возвращает 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.
Возвращает 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(), который более надежен.