140 lines
6.1 KiB
Java
140 lines
6.1 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* org.joml.Matrix3x2fc
|
|
* org.joml.Vector2f
|
|
* org.jspecify.annotations.Nullable
|
|
*/
|
|
package net.minecraft.client.gui.navigation;
|
|
|
|
import net.minecraft.client.gui.navigation.ScreenAxis;
|
|
import net.minecraft.client.gui.navigation.ScreenDirection;
|
|
import net.minecraft.client.gui.navigation.ScreenPosition;
|
|
import net.minecraft.util.Mth;
|
|
import org.joml.Matrix3x2fc;
|
|
import org.joml.Vector2f;
|
|
import org.jspecify.annotations.Nullable;
|
|
|
|
public record ScreenRectangle(ScreenPosition position, int width, int height) {
|
|
private static final ScreenRectangle EMPTY = new ScreenRectangle(0, 0, 0, 0);
|
|
|
|
public ScreenRectangle(int x, int y, int width, int height) {
|
|
this(new ScreenPosition(x, y), width, height);
|
|
}
|
|
|
|
public static ScreenRectangle empty() {
|
|
return EMPTY;
|
|
}
|
|
|
|
public static ScreenRectangle of(ScreenAxis primaryAxis, int primaryIndex, int secondaryIndex, int primaryLength, int secondaryLength) {
|
|
return switch (primaryAxis) {
|
|
default -> throw new MatchException(null, null);
|
|
case ScreenAxis.HORIZONTAL -> new ScreenRectangle(primaryIndex, secondaryIndex, primaryLength, secondaryLength);
|
|
case ScreenAxis.VERTICAL -> new ScreenRectangle(secondaryIndex, primaryIndex, secondaryLength, primaryLength);
|
|
};
|
|
}
|
|
|
|
public ScreenRectangle step(ScreenDirection direction) {
|
|
return new ScreenRectangle(this.position.step(direction), this.width, this.height);
|
|
}
|
|
|
|
public int getLength(ScreenAxis axis) {
|
|
return switch (axis) {
|
|
default -> throw new MatchException(null, null);
|
|
case ScreenAxis.HORIZONTAL -> this.width;
|
|
case ScreenAxis.VERTICAL -> this.height;
|
|
};
|
|
}
|
|
|
|
public int getBoundInDirection(ScreenDirection direction) {
|
|
ScreenAxis axis = direction.getAxis();
|
|
if (direction.isPositive()) {
|
|
return this.position.getCoordinate(axis) + this.getLength(axis) - 1;
|
|
}
|
|
return this.position.getCoordinate(axis);
|
|
}
|
|
|
|
public ScreenRectangle getBorder(ScreenDirection direction) {
|
|
int startFirst = this.getBoundInDirection(direction);
|
|
ScreenAxis orthogonalAxis = direction.getAxis().orthogonal();
|
|
int startSecond = this.getBoundInDirection(orthogonalAxis.getNegative());
|
|
int length = this.getLength(orthogonalAxis);
|
|
return ScreenRectangle.of(direction.getAxis(), startFirst, startSecond, 1, length).step(direction);
|
|
}
|
|
|
|
public boolean overlaps(ScreenRectangle other) {
|
|
return this.overlapsInAxis(other, ScreenAxis.HORIZONTAL) && this.overlapsInAxis(other, ScreenAxis.VERTICAL);
|
|
}
|
|
|
|
public boolean overlapsInAxis(ScreenRectangle other, ScreenAxis axis) {
|
|
int thisLower = this.getBoundInDirection(axis.getNegative());
|
|
int otherLower = other.getBoundInDirection(axis.getNegative());
|
|
int thisHigher = this.getBoundInDirection(axis.getPositive());
|
|
int otherHigher = other.getBoundInDirection(axis.getPositive());
|
|
return Math.max(thisLower, otherLower) <= Math.min(thisHigher, otherHigher);
|
|
}
|
|
|
|
public int getCenterInAxis(ScreenAxis axis) {
|
|
return (this.getBoundInDirection(axis.getPositive()) + this.getBoundInDirection(axis.getNegative())) / 2;
|
|
}
|
|
|
|
public @Nullable ScreenRectangle intersection(ScreenRectangle other) {
|
|
int left = Math.max(this.left(), other.left());
|
|
int top = Math.max(this.top(), other.top());
|
|
int right = Math.min(this.right(), other.right());
|
|
int bottom = Math.min(this.bottom(), other.bottom());
|
|
if (left >= right || top >= bottom) {
|
|
return null;
|
|
}
|
|
return new ScreenRectangle(left, top, right - left, bottom - top);
|
|
}
|
|
|
|
public boolean intersects(ScreenRectangle other) {
|
|
return this.left() < other.right() && this.right() > other.left() && this.top() < other.bottom() && this.bottom() > other.top();
|
|
}
|
|
|
|
public boolean encompasses(ScreenRectangle other) {
|
|
return other.left() >= this.left() && other.top() >= this.top() && other.right() <= this.right() && other.bottom() <= this.bottom();
|
|
}
|
|
|
|
public int top() {
|
|
return this.position.y();
|
|
}
|
|
|
|
public int bottom() {
|
|
return this.position.y() + this.height;
|
|
}
|
|
|
|
public int left() {
|
|
return this.position.x();
|
|
}
|
|
|
|
public int right() {
|
|
return this.position.x() + this.width;
|
|
}
|
|
|
|
public boolean containsPoint(int x, int y) {
|
|
return x >= this.left() && x < this.right() && y >= this.top() && y < this.bottom();
|
|
}
|
|
|
|
public ScreenRectangle transformAxisAligned(Matrix3x2fc matrix) {
|
|
Vector2f topLeft = matrix.transformPosition((float)this.left(), (float)this.top(), new Vector2f());
|
|
Vector2f bottomRight = matrix.transformPosition((float)this.right(), (float)this.bottom(), new Vector2f());
|
|
return new ScreenRectangle(Mth.floor(topLeft.x), Mth.floor(topLeft.y), Mth.floor(bottomRight.x - topLeft.x), Mth.floor(bottomRight.y - topLeft.y));
|
|
}
|
|
|
|
public ScreenRectangle transformMaxBounds(Matrix3x2fc matrix) {
|
|
Vector2f topLeft = matrix.transformPosition((float)this.left(), (float)this.top(), new Vector2f());
|
|
Vector2f topRight = matrix.transformPosition((float)this.right(), (float)this.top(), new Vector2f());
|
|
Vector2f bottomLeft = matrix.transformPosition((float)this.left(), (float)this.bottom(), new Vector2f());
|
|
Vector2f bottomRight = matrix.transformPosition((float)this.right(), (float)this.bottom(), new Vector2f());
|
|
float minX = Math.min(Math.min(topLeft.x(), bottomLeft.x()), Math.min(topRight.x(), bottomRight.x()));
|
|
float maxX = Math.max(Math.max(topLeft.x(), bottomLeft.x()), Math.max(topRight.x(), bottomRight.x()));
|
|
float minY = Math.min(Math.min(topLeft.y(), bottomLeft.y()), Math.min(topRight.y(), bottomRight.y()));
|
|
float maxY = Math.max(Math.max(topLeft.y(), bottomLeft.y()), Math.max(topRight.y(), bottomRight.y()));
|
|
return new ScreenRectangle(Mth.floor(minX), Mth.floor(minY), Mth.ceil(maxX - minX), Mth.ceil(maxY - minY));
|
|
}
|
|
}
|
|
|