94 lines
4.9 KiB
Java
94 lines
4.9 KiB
Java
package fr.adrien1106.reframed.client.model;
|
|
|
|
import net.fabricmc.api.EnvType;
|
|
import net.fabricmc.api.Environment;
|
|
import net.fabricmc.fabric.api.renderer.v1.mesh.MutableQuadView;
|
|
import net.fabricmc.fabric.api.renderer.v1.mesh.QuadView;
|
|
import net.minecraft.util.math.Direction;
|
|
import net.minecraft.util.math.MathHelper;
|
|
import org.joml.Vector3f;
|
|
|
|
@Environment(EnvType.CLIENT)
|
|
public record QuadPosBounds(float min_x, float max_x, float min_y, float max_y, float min_z, float max_z) {
|
|
|
|
public static QuadPosBounds read(QuadView quad) {
|
|
return read(quad, true);
|
|
}
|
|
|
|
public static QuadPosBounds read(QuadView quad, boolean check_full) {
|
|
float x0 = quad.x(0), x1 = quad.x(1), x2 = quad.x(2), x3 = quad.x(3);
|
|
float y0 = quad.y(0), y1 = quad.y(1), y2 = quad.y(2), y3 = quad.y(3);
|
|
float z0 = quad.z(0), z1 = quad.z(1), z2 = quad.z(2), z3 = quad.z(3);
|
|
|
|
// Checks if the Dimensions are either 0 or 1 except for the Axis dimension
|
|
Direction.Axis axis = quad.nominalFace().getAxis();
|
|
if (check_full && (axis == Direction.Axis.X || (
|
|
(MathHelper.approximatelyEquals(x0, 0) || MathHelper.approximatelyEquals(x0, 1))
|
|
&& (MathHelper.approximatelyEquals(x1, 0) || MathHelper.approximatelyEquals(x1, 1))
|
|
&& (MathHelper.approximatelyEquals(x2, 0) || MathHelper.approximatelyEquals(x2, 1))
|
|
&& (MathHelper.approximatelyEquals(x3, 0) || MathHelper.approximatelyEquals(x3, 1))
|
|
)) && (axis == Direction.Axis.Y || (
|
|
(MathHelper.approximatelyEquals(y0, 0) || MathHelper.approximatelyEquals(y0, 1))
|
|
&& (MathHelper.approximatelyEquals(y1, 0) || MathHelper.approximatelyEquals(y1, 1))
|
|
&& (MathHelper.approximatelyEquals(y2, 0) || MathHelper.approximatelyEquals(y2, 1))
|
|
&& (MathHelper.approximatelyEquals(y3, 0) || MathHelper.approximatelyEquals(y3, 1))
|
|
)) & (axis == Direction.Axis.Z || (
|
|
(MathHelper.approximatelyEquals(z0, 0) || MathHelper.approximatelyEquals(z0, 1))
|
|
&& (MathHelper.approximatelyEquals(z1, 0) || MathHelper.approximatelyEquals(z1, 1))
|
|
&& (MathHelper.approximatelyEquals(z2, 0) || MathHelper.approximatelyEquals(z2, 1))
|
|
&& (MathHelper.approximatelyEquals(z3, 0) || MathHelper.approximatelyEquals(z3, 1))
|
|
))
|
|
) return null;
|
|
|
|
return new QuadPosBounds(
|
|
Math.min(Math.min(x0, x1), Math.min(x2, x3)),
|
|
Math.max(Math.max(x0, x1), Math.max(x2, x3)),
|
|
Math.min(Math.min(y0, y1), Math.min(y2, y3)),
|
|
Math.max(Math.max(y0, y1), Math.max(y2, y3)),
|
|
Math.min(Math.min(z0, z1), Math.min(z2, z3)),
|
|
Math.max(Math.max(z0, z1), Math.max(z2, z3))
|
|
);
|
|
}
|
|
|
|
public boolean matches(QuadPosBounds other_bounds) {
|
|
return !(
|
|
(min_x != max_x && (min_x >= other_bounds.max_x || max_x <= other_bounds.min_x))
|
|
|| (min_y != max_y && (min_y >= other_bounds.max_y || max_y <= other_bounds.min_y))
|
|
|| (min_z != max_z && (min_z >= other_bounds.max_z || max_z <= other_bounds.min_z))
|
|
);
|
|
}
|
|
|
|
public QuadPosBounds intersection(QuadPosBounds other_bounds, Direction.Axis axis) {
|
|
return new QuadPosBounds(
|
|
axis.equals(Direction.Axis.X) ? other_bounds.min_x: Math.max(min_x, other_bounds.min_x),
|
|
axis.equals(Direction.Axis.X) ? other_bounds.max_x: Math.min(max_x, other_bounds.max_x),
|
|
axis.equals(Direction.Axis.Y) ? other_bounds.min_y: Math.max(min_y, other_bounds.min_y),
|
|
axis.equals(Direction.Axis.Y) ? other_bounds.max_y: Math.min(max_y, other_bounds.max_y),
|
|
axis.equals(Direction.Axis.Z) ? other_bounds.min_z: Math.max(min_z, other_bounds.min_z),
|
|
axis.equals(Direction.Axis.Z) ? other_bounds.max_z: Math.min(max_z, other_bounds.max_z)
|
|
);
|
|
}
|
|
|
|
public void apply(MutableQuadView quad, QuadPosBounds origin_bounds) {
|
|
Vector3f pos = new Vector3f();
|
|
for (int i = 0; i < 4; i++) {
|
|
quad.copyPos(i, pos);
|
|
pos.x = MathHelper.approximatelyEquals(pos.x, origin_bounds.min_x)? min_x: max_x;
|
|
pos.y = MathHelper.approximatelyEquals(pos.y, origin_bounds.min_y)? min_y: max_y;
|
|
pos.z = MathHelper.approximatelyEquals(pos.z, origin_bounds.min_z)? min_z: max_z;
|
|
quad.pos(i, pos);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof QuadPosBounds other)) return false;
|
|
return MathHelper.approximatelyEquals(min_x, other.min_x)
|
|
&& MathHelper.approximatelyEquals(min_y, other.min_y)
|
|
&& MathHelper.approximatelyEquals(min_z, other.min_z)
|
|
&& MathHelper.approximatelyEquals(max_x, other.max_x)
|
|
&& MathHelper.approximatelyEquals(max_y, other.max_y)
|
|
&& MathHelper.approximatelyEquals(max_z, other.max_z);
|
|
}
|
|
}
|