739 lines
25 KiB
Java
739 lines
25 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* org.apache.commons.lang3.math.Fraction
|
|
* org.apache.commons.lang3.math.NumberUtils
|
|
* org.joml.Math
|
|
* org.joml.Quaternionf
|
|
* org.joml.Vector3f
|
|
*/
|
|
package net.minecraft.util;
|
|
|
|
import java.util.Locale;
|
|
import java.util.UUID;
|
|
import java.util.function.IntPredicate;
|
|
import java.util.stream.IntStream;
|
|
import net.minecraft.core.Vec3i;
|
|
import net.minecraft.util.ARGB;
|
|
import net.minecraft.util.RandomSource;
|
|
import net.minecraft.util.Util;
|
|
import net.minecraft.world.phys.AABB;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.apache.commons.lang3.math.Fraction;
|
|
import org.apache.commons.lang3.math.NumberUtils;
|
|
import org.joml.Math;
|
|
import org.joml.Quaternionf;
|
|
import org.joml.Vector3f;
|
|
|
|
public class Mth {
|
|
private static final long UUID_VERSION = 61440L;
|
|
private static final long UUID_VERSION_TYPE_4 = 16384L;
|
|
private static final long UUID_VARIANT = -4611686018427387904L;
|
|
private static final long UUID_VARIANT_2 = Long.MIN_VALUE;
|
|
public static final float PI = (float)java.lang.Math.PI;
|
|
public static final float HALF_PI = 1.5707964f;
|
|
public static final float TWO_PI = (float)java.lang.Math.PI * 2;
|
|
public static final float DEG_TO_RAD = (float)java.lang.Math.PI / 180;
|
|
public static final float RAD_TO_DEG = 57.295776f;
|
|
public static final float EPSILON = 1.0E-5f;
|
|
public static final float SQRT_OF_TWO = Mth.sqrt(2.0f);
|
|
public static final Vector3f Y_AXIS = new Vector3f(0.0f, 1.0f, 0.0f);
|
|
public static final Vector3f X_AXIS = new Vector3f(1.0f, 0.0f, 0.0f);
|
|
public static final Vector3f Z_AXIS = new Vector3f(0.0f, 0.0f, 1.0f);
|
|
private static final int SIN_QUANTIZATION = 65536;
|
|
private static final int SIN_MASK = 65535;
|
|
private static final int COS_OFFSET = 16384;
|
|
private static final double SIN_SCALE = 10430.378350470453;
|
|
private static final float[] SIN = Util.make(new float[65536], sin -> {
|
|
for (int i = 0; i < ((float[])sin).length; ++i) {
|
|
sin[i] = (float)java.lang.Math.sin((double)i / 10430.378350470453);
|
|
}
|
|
});
|
|
private static final RandomSource RANDOM = RandomSource.createThreadSafe();
|
|
private static final int[] MULTIPLY_DE_BRUIJN_BIT_POSITION = new int[]{0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
|
|
private static final double ONE_SIXTH = 0.16666666666666666;
|
|
private static final int FRAC_EXP = 8;
|
|
private static final int LUT_SIZE = 257;
|
|
private static final double FRAC_BIAS = Double.longBitsToDouble(4805340802404319232L);
|
|
private static final double[] ASIN_TAB = new double[257];
|
|
private static final double[] COS_TAB = new double[257];
|
|
|
|
public static float sin(double i) {
|
|
return SIN[(int)((long)(i * 10430.378350470453) & 0xFFFFL)];
|
|
}
|
|
|
|
public static float cos(double i) {
|
|
return SIN[(int)((long)(i * 10430.378350470453 + 16384.0) & 0xFFFFL)];
|
|
}
|
|
|
|
public static float sqrt(float x) {
|
|
return (float)java.lang.Math.sqrt(x);
|
|
}
|
|
|
|
public static int floor(float v) {
|
|
int i = (int)v;
|
|
return v < (float)i ? i - 1 : i;
|
|
}
|
|
|
|
public static int floor(double v) {
|
|
int i = (int)v;
|
|
return v < (double)i ? i - 1 : i;
|
|
}
|
|
|
|
public static long lfloor(double v) {
|
|
long i = (long)v;
|
|
return v < (double)i ? i - 1L : i;
|
|
}
|
|
|
|
public static float abs(float v) {
|
|
return java.lang.Math.abs(v);
|
|
}
|
|
|
|
public static int abs(int v) {
|
|
return java.lang.Math.abs(v);
|
|
}
|
|
|
|
public static int ceil(float v) {
|
|
int i = (int)v;
|
|
return v > (float)i ? i + 1 : i;
|
|
}
|
|
|
|
public static int ceil(double v) {
|
|
int i = (int)v;
|
|
return v > (double)i ? i + 1 : i;
|
|
}
|
|
|
|
public static long ceilLong(double v) {
|
|
long l = (long)v;
|
|
return v > (double)l ? l + 1L : l;
|
|
}
|
|
|
|
public static int clamp(int value, int min, int max) {
|
|
return java.lang.Math.min(java.lang.Math.max(value, min), max);
|
|
}
|
|
|
|
public static long clamp(long value, long min, long max) {
|
|
return java.lang.Math.min(java.lang.Math.max(value, min), max);
|
|
}
|
|
|
|
public static float clamp(float value, float min, float max) {
|
|
if (value < min) {
|
|
return min;
|
|
}
|
|
return java.lang.Math.min(value, max);
|
|
}
|
|
|
|
public static double clamp(double value, double min, double max) {
|
|
if (value < min) {
|
|
return min;
|
|
}
|
|
return java.lang.Math.min(value, max);
|
|
}
|
|
|
|
public static double clampedLerp(double factor, double min, double max) {
|
|
if (factor < 0.0) {
|
|
return min;
|
|
}
|
|
if (factor > 1.0) {
|
|
return max;
|
|
}
|
|
return Mth.lerp(factor, min, max);
|
|
}
|
|
|
|
public static float clampedLerp(float factor, float min, float max) {
|
|
if (factor < 0.0f) {
|
|
return min;
|
|
}
|
|
if (factor > 1.0f) {
|
|
return max;
|
|
}
|
|
return Mth.lerp(factor, min, max);
|
|
}
|
|
|
|
public static double absMax(double a, double b) {
|
|
return java.lang.Math.max(java.lang.Math.abs(a), java.lang.Math.abs(b));
|
|
}
|
|
|
|
public static int floorDiv(int a, int b) {
|
|
return java.lang.Math.floorDiv(a, b);
|
|
}
|
|
|
|
public static int nextInt(RandomSource random, int minInclusive, int maxInclusive) {
|
|
if (minInclusive >= maxInclusive) {
|
|
return minInclusive;
|
|
}
|
|
return random.nextInt(maxInclusive - minInclusive + 1) + minInclusive;
|
|
}
|
|
|
|
public static float nextFloat(RandomSource random, float min, float max) {
|
|
if (min >= max) {
|
|
return min;
|
|
}
|
|
return random.nextFloat() * (max - min) + min;
|
|
}
|
|
|
|
public static double nextDouble(RandomSource random, double min, double max) {
|
|
if (min >= max) {
|
|
return min;
|
|
}
|
|
return random.nextDouble() * (max - min) + min;
|
|
}
|
|
|
|
public static boolean equal(float a, float b) {
|
|
return java.lang.Math.abs(b - a) < 1.0E-5f;
|
|
}
|
|
|
|
public static boolean equal(double a, double b) {
|
|
return java.lang.Math.abs(b - a) < (double)1.0E-5f;
|
|
}
|
|
|
|
public static int positiveModulo(int input, int mod) {
|
|
return java.lang.Math.floorMod(input, mod);
|
|
}
|
|
|
|
public static float positiveModulo(float input, float mod) {
|
|
return (input % mod + mod) % mod;
|
|
}
|
|
|
|
public static double positiveModulo(double input, double mod) {
|
|
return (input % mod + mod) % mod;
|
|
}
|
|
|
|
public static boolean isMultipleOf(int dividend, int divisor) {
|
|
return dividend % divisor == 0;
|
|
}
|
|
|
|
public static byte packDegrees(float angle) {
|
|
return (byte)Mth.floor(angle * 256.0f / 360.0f);
|
|
}
|
|
|
|
public static float unpackDegrees(byte rot) {
|
|
return (float)(rot * 360) / 256.0f;
|
|
}
|
|
|
|
public static int wrapDegrees(int angle) {
|
|
int normalizedAngle = angle % 360;
|
|
if (normalizedAngle >= 180) {
|
|
normalizedAngle -= 360;
|
|
}
|
|
if (normalizedAngle < -180) {
|
|
normalizedAngle += 360;
|
|
}
|
|
return normalizedAngle;
|
|
}
|
|
|
|
public static float wrapDegrees(long angle) {
|
|
float normalizedAngle = angle % 360L;
|
|
if (normalizedAngle >= 180.0f) {
|
|
normalizedAngle -= 360.0f;
|
|
}
|
|
if (normalizedAngle < -180.0f) {
|
|
normalizedAngle += 360.0f;
|
|
}
|
|
return normalizedAngle;
|
|
}
|
|
|
|
public static float wrapDegrees(float angle) {
|
|
float normalizedAngle = angle % 360.0f;
|
|
if (normalizedAngle >= 180.0f) {
|
|
normalizedAngle -= 360.0f;
|
|
}
|
|
if (normalizedAngle < -180.0f) {
|
|
normalizedAngle += 360.0f;
|
|
}
|
|
return normalizedAngle;
|
|
}
|
|
|
|
public static double wrapDegrees(double angle) {
|
|
double normalizedAngle = angle % 360.0;
|
|
if (normalizedAngle >= 180.0) {
|
|
normalizedAngle -= 360.0;
|
|
}
|
|
if (normalizedAngle < -180.0) {
|
|
normalizedAngle += 360.0;
|
|
}
|
|
return normalizedAngle;
|
|
}
|
|
|
|
public static float degreesDifference(float fromAngle, float toAngle) {
|
|
return Mth.wrapDegrees(toAngle - fromAngle);
|
|
}
|
|
|
|
public static float degreesDifferenceAbs(float angleA, float angleB) {
|
|
return Mth.abs(Mth.degreesDifference(angleA, angleB));
|
|
}
|
|
|
|
public static float rotateIfNecessary(float baseAngle, float targetAngle, float maxAngleDiff) {
|
|
float deltaAngle = Mth.degreesDifference(baseAngle, targetAngle);
|
|
float deltaAngleClamped = Mth.clamp(deltaAngle, -maxAngleDiff, maxAngleDiff);
|
|
return targetAngle - deltaAngleClamped;
|
|
}
|
|
|
|
public static float approach(float current, float target, float increment) {
|
|
increment = Mth.abs(increment);
|
|
if (current < target) {
|
|
return Mth.clamp(current + increment, current, target);
|
|
}
|
|
return Mth.clamp(current - increment, target, current);
|
|
}
|
|
|
|
public static float approachDegrees(float current, float target, float increment) {
|
|
float difference = Mth.degreesDifference(current, target);
|
|
return Mth.approach(current, current + difference, increment);
|
|
}
|
|
|
|
public static int getInt(String input, int def) {
|
|
return NumberUtils.toInt((String)input, (int)def);
|
|
}
|
|
|
|
public static int smallestEncompassingPowerOfTwo(int input) {
|
|
int result = input - 1;
|
|
result |= result >> 1;
|
|
result |= result >> 2;
|
|
result |= result >> 4;
|
|
result |= result >> 8;
|
|
result |= result >> 16;
|
|
return result + 1;
|
|
}
|
|
|
|
public static int smallestSquareSide(int itemCount) {
|
|
if (itemCount < 0) {
|
|
throw new IllegalArgumentException("itemCount must be greater than or equal to zero");
|
|
}
|
|
return Mth.ceil(java.lang.Math.sqrt(itemCount));
|
|
}
|
|
|
|
public static boolean isPowerOfTwo(int input) {
|
|
return input != 0 && (input & input - 1) == 0;
|
|
}
|
|
|
|
public static int ceillog2(int input) {
|
|
input = Mth.isPowerOfTwo(input) ? input : Mth.smallestEncompassingPowerOfTwo(input);
|
|
return MULTIPLY_DE_BRUIJN_BIT_POSITION[(int)((long)input * 125613361L >> 27) & 0x1F];
|
|
}
|
|
|
|
public static int log2(int input) {
|
|
return Mth.ceillog2(input) - (Mth.isPowerOfTwo(input) ? 0 : 1);
|
|
}
|
|
|
|
public static float frac(float num) {
|
|
return num - (float)Mth.floor(num);
|
|
}
|
|
|
|
public static double frac(double num) {
|
|
return num - (double)Mth.lfloor(num);
|
|
}
|
|
|
|
@Deprecated
|
|
public static long getSeed(Vec3i vec) {
|
|
return Mth.getSeed(vec.getX(), vec.getY(), vec.getZ());
|
|
}
|
|
|
|
@Deprecated
|
|
public static long getSeed(int x, int y, int z) {
|
|
long seed = (long)(x * 3129871) ^ (long)z * 116129781L ^ (long)y;
|
|
seed = seed * seed * 42317861L + seed * 11L;
|
|
return seed >> 16;
|
|
}
|
|
|
|
public static UUID createInsecureUUID(RandomSource random) {
|
|
long most = random.nextLong() & 0xFFFFFFFFFFFF0FFFL | 0x4000L;
|
|
long least = random.nextLong() & 0x3FFFFFFFFFFFFFFFL | Long.MIN_VALUE;
|
|
return new UUID(most, least);
|
|
}
|
|
|
|
public static UUID createInsecureUUID() {
|
|
return Mth.createInsecureUUID(RANDOM);
|
|
}
|
|
|
|
public static double inverseLerp(double value, double min, double max) {
|
|
return (value - min) / (max - min);
|
|
}
|
|
|
|
public static float inverseLerp(float value, float min, float max) {
|
|
return (value - min) / (max - min);
|
|
}
|
|
|
|
public static boolean rayIntersectsAABB(Vec3 rayStart, Vec3 rayDir, AABB aabb) {
|
|
double centerX = (aabb.minX + aabb.maxX) * 0.5;
|
|
double boxExtentX = (aabb.maxX - aabb.minX) * 0.5;
|
|
double diffX = rayStart.x - centerX;
|
|
if (java.lang.Math.abs(diffX) > boxExtentX && diffX * rayDir.x >= 0.0) {
|
|
return false;
|
|
}
|
|
double centerY = (aabb.minY + aabb.maxY) * 0.5;
|
|
double boxExtentY = (aabb.maxY - aabb.minY) * 0.5;
|
|
double diffY = rayStart.y - centerY;
|
|
if (java.lang.Math.abs(diffY) > boxExtentY && diffY * rayDir.y >= 0.0) {
|
|
return false;
|
|
}
|
|
double centerZ = (aabb.minZ + aabb.maxZ) * 0.5;
|
|
double boxExtentZ = (aabb.maxZ - aabb.minZ) * 0.5;
|
|
double diffZ = rayStart.z - centerZ;
|
|
if (java.lang.Math.abs(diffZ) > boxExtentZ && diffZ * rayDir.z >= 0.0) {
|
|
return false;
|
|
}
|
|
double andrewWooDiffX = java.lang.Math.abs(rayDir.x);
|
|
double andrewWooDiffY = java.lang.Math.abs(rayDir.y);
|
|
double andrewWooDiffZ = java.lang.Math.abs(rayDir.z);
|
|
double f = rayDir.y * diffZ - rayDir.z * diffY;
|
|
if (java.lang.Math.abs(f) > boxExtentY * andrewWooDiffZ + boxExtentZ * andrewWooDiffY) {
|
|
return false;
|
|
}
|
|
f = rayDir.z * diffX - rayDir.x * diffZ;
|
|
if (java.lang.Math.abs(f) > boxExtentX * andrewWooDiffZ + boxExtentZ * andrewWooDiffX) {
|
|
return false;
|
|
}
|
|
f = rayDir.x * diffY - rayDir.y * diffX;
|
|
return java.lang.Math.abs(f) < boxExtentX * andrewWooDiffY + boxExtentY * andrewWooDiffX;
|
|
}
|
|
|
|
public static double atan2(double y, double x) {
|
|
boolean steep;
|
|
boolean negX;
|
|
boolean negY;
|
|
double d2 = x * x + y * y;
|
|
if (Double.isNaN(d2)) {
|
|
return Double.NaN;
|
|
}
|
|
boolean bl = negY = y < 0.0;
|
|
if (negY) {
|
|
y = -y;
|
|
}
|
|
boolean bl2 = negX = x < 0.0;
|
|
if (negX) {
|
|
x = -x;
|
|
}
|
|
boolean bl3 = steep = y > x;
|
|
if (steep) {
|
|
double t = x;
|
|
x = y;
|
|
y = t;
|
|
}
|
|
double rinv = Mth.fastInvSqrt(d2);
|
|
x *= rinv;
|
|
double yp = FRAC_BIAS + (y *= rinv);
|
|
int index = (int)Double.doubleToRawLongBits(yp);
|
|
double phi = ASIN_TAB[index];
|
|
double cPhi = COS_TAB[index];
|
|
double sPhi = yp - FRAC_BIAS;
|
|
double sd = y * cPhi - x * sPhi;
|
|
double d = (6.0 + sd * sd) * sd * 0.16666666666666666;
|
|
double theta = phi + d;
|
|
if (steep) {
|
|
theta = 1.5707963267948966 - theta;
|
|
}
|
|
if (negX) {
|
|
theta = java.lang.Math.PI - theta;
|
|
}
|
|
if (negY) {
|
|
theta = -theta;
|
|
}
|
|
return theta;
|
|
}
|
|
|
|
public static float invSqrt(float x) {
|
|
return Math.invsqrt((float)x);
|
|
}
|
|
|
|
public static double invSqrt(double x) {
|
|
return Math.invsqrt((double)x);
|
|
}
|
|
|
|
@Deprecated
|
|
public static double fastInvSqrt(double x) {
|
|
double xhalf = 0.5 * x;
|
|
long i = Double.doubleToRawLongBits(x);
|
|
i = 6910469410427058090L - (i >> 1);
|
|
x = Double.longBitsToDouble(i);
|
|
x *= 1.5 - xhalf * x * x;
|
|
return x;
|
|
}
|
|
|
|
public static float fastInvCubeRoot(float x) {
|
|
int i = Float.floatToIntBits(x);
|
|
i = 1419967116 - i / 3;
|
|
float y = Float.intBitsToFloat(i);
|
|
y = 0.6666667f * y + 1.0f / (3.0f * y * y * x);
|
|
y = 0.6666667f * y + 1.0f / (3.0f * y * y * x);
|
|
return y;
|
|
}
|
|
|
|
public static int hsvToRgb(float hue, float saturation, float value) {
|
|
return Mth.hsvToArgb(hue, saturation, value, 0);
|
|
}
|
|
|
|
public static int hsvToArgb(float hue, float saturation, float value, int alpha) {
|
|
float green;
|
|
float red;
|
|
int h = (int)(hue * 6.0f) % 6;
|
|
float f = hue * 6.0f - (float)h;
|
|
float p = value * (1.0f - saturation);
|
|
float q = value * (1.0f - f * saturation);
|
|
float t = value * (1.0f - (1.0f - f) * saturation);
|
|
return ARGB.color(alpha, Mth.clamp((int)(red * 255.0f), 0, 255), Mth.clamp((int)(green * 255.0f), 0, 255), Mth.clamp((int)((switch (h) {
|
|
case 0 -> {
|
|
red = value;
|
|
green = t;
|
|
yield p;
|
|
}
|
|
case 1 -> {
|
|
red = q;
|
|
green = value;
|
|
yield p;
|
|
}
|
|
case 2 -> {
|
|
red = p;
|
|
green = value;
|
|
yield t;
|
|
}
|
|
case 3 -> {
|
|
red = p;
|
|
green = q;
|
|
yield value;
|
|
}
|
|
case 4 -> {
|
|
red = t;
|
|
green = p;
|
|
yield value;
|
|
}
|
|
case 5 -> {
|
|
red = value;
|
|
green = p;
|
|
yield q;
|
|
}
|
|
default -> throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + hue + ", " + saturation + ", " + value);
|
|
}) * 255.0f), 0, 255));
|
|
}
|
|
|
|
public static int murmurHash3Mixer(int hash) {
|
|
hash ^= hash >>> 16;
|
|
hash *= -2048144789;
|
|
hash ^= hash >>> 13;
|
|
hash *= -1028477387;
|
|
hash ^= hash >>> 16;
|
|
return hash;
|
|
}
|
|
|
|
public static int binarySearch(int from, int to, IntPredicate condition) {
|
|
int len = to - from;
|
|
while (len > 0) {
|
|
int half = len / 2;
|
|
int middle = from + half;
|
|
if (condition.test(middle)) {
|
|
len = half;
|
|
continue;
|
|
}
|
|
from = middle + 1;
|
|
len -= half + 1;
|
|
}
|
|
return from;
|
|
}
|
|
|
|
public static int lerpInt(float alpha1, int p0, int p1) {
|
|
return p0 + Mth.floor(alpha1 * (float)(p1 - p0));
|
|
}
|
|
|
|
public static int lerpDiscrete(float alpha1, int p0, int p1) {
|
|
int delta = p1 - p0;
|
|
return p0 + Mth.floor(alpha1 * (float)(delta - 1)) + (alpha1 > 0.0f ? 1 : 0);
|
|
}
|
|
|
|
public static float lerp(float alpha1, float p0, float p1) {
|
|
return p0 + alpha1 * (p1 - p0);
|
|
}
|
|
|
|
public static Vec3 lerp(double alpha, Vec3 p1, Vec3 p2) {
|
|
return new Vec3(Mth.lerp(alpha, p1.x, p2.x), Mth.lerp(alpha, p1.y, p2.y), Mth.lerp(alpha, p1.z, p2.z));
|
|
}
|
|
|
|
public static double lerp(double alpha1, double p0, double p1) {
|
|
return p0 + alpha1 * (p1 - p0);
|
|
}
|
|
|
|
public static double lerp2(double alpha1, double alpha2, double x00, double x10, double x01, double x11) {
|
|
return Mth.lerp(alpha2, Mth.lerp(alpha1, x00, x10), Mth.lerp(alpha1, x01, x11));
|
|
}
|
|
|
|
public static double lerp3(double alpha1, double alpha2, double alpha3, double x000, double x100, double x010, double x110, double x001, double x101, double x011, double x111) {
|
|
return Mth.lerp(alpha3, Mth.lerp2(alpha1, alpha2, x000, x100, x010, x110), Mth.lerp2(alpha1, alpha2, x001, x101, x011, x111));
|
|
}
|
|
|
|
public static float catmullrom(float alpha, float p0, float p1, float p2, float p3) {
|
|
return 0.5f * (2.0f * p1 + (p2 - p0) * alpha + (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * alpha * alpha + (3.0f * p1 - p0 - 3.0f * p2 + p3) * alpha * alpha * alpha);
|
|
}
|
|
|
|
public static double smoothstep(double x) {
|
|
return x * x * x * (x * (x * 6.0 - 15.0) + 10.0);
|
|
}
|
|
|
|
public static double smoothstepDerivative(double x) {
|
|
return 30.0 * x * x * (x - 1.0) * (x - 1.0);
|
|
}
|
|
|
|
public static int sign(double number) {
|
|
if (number == 0.0) {
|
|
return 0;
|
|
}
|
|
return number > 0.0 ? 1 : -1;
|
|
}
|
|
|
|
public static float rotLerp(float a, float from, float to) {
|
|
return from + a * Mth.wrapDegrees(to - from);
|
|
}
|
|
|
|
public static double rotLerp(double a, double from, double to) {
|
|
return from + a * Mth.wrapDegrees(to - from);
|
|
}
|
|
|
|
public static float rotLerpRad(float a, float from, float to) {
|
|
float diff;
|
|
for (diff = to - from; diff < (float)(-java.lang.Math.PI); diff += (float)java.lang.Math.PI * 2) {
|
|
}
|
|
while (diff >= (float)java.lang.Math.PI) {
|
|
diff -= (float)java.lang.Math.PI * 2;
|
|
}
|
|
return from + a * diff;
|
|
}
|
|
|
|
public static float triangleWave(float index, float period) {
|
|
return (java.lang.Math.abs(index % period - period * 0.5f) - period * 0.25f) / (period * 0.25f);
|
|
}
|
|
|
|
public static float square(float x) {
|
|
return x * x;
|
|
}
|
|
|
|
public static float cube(float x) {
|
|
return x * x * x;
|
|
}
|
|
|
|
public static double square(double x) {
|
|
return x * x;
|
|
}
|
|
|
|
public static int square(int x) {
|
|
return x * x;
|
|
}
|
|
|
|
public static long square(long x) {
|
|
return x * x;
|
|
}
|
|
|
|
public static double clampedMap(double value, double fromMin, double fromMax, double toMin, double toMax) {
|
|
return Mth.clampedLerp(Mth.inverseLerp(value, fromMin, fromMax), toMin, toMax);
|
|
}
|
|
|
|
public static float clampedMap(float value, float fromMin, float fromMax, float toMin, float toMax) {
|
|
return Mth.clampedLerp(Mth.inverseLerp(value, fromMin, fromMax), toMin, toMax);
|
|
}
|
|
|
|
public static double map(double value, double fromMin, double fromMax, double toMin, double toMax) {
|
|
return Mth.lerp(Mth.inverseLerp(value, fromMin, fromMax), toMin, toMax);
|
|
}
|
|
|
|
public static float map(float value, float fromMin, float fromMax, float toMin, float toMax) {
|
|
return Mth.lerp(Mth.inverseLerp(value, fromMin, fromMax), toMin, toMax);
|
|
}
|
|
|
|
public static double wobble(double coord) {
|
|
return coord + (2.0 * RandomSource.create(Mth.floor(coord * 3000.0)).nextDouble() - 1.0) * 1.0E-7 / 2.0;
|
|
}
|
|
|
|
public static int roundToward(int input, int multiple) {
|
|
return Mth.positiveCeilDiv(input, multiple) * multiple;
|
|
}
|
|
|
|
public static int positiveCeilDiv(int input, int divisor) {
|
|
return -java.lang.Math.floorDiv(-input, divisor);
|
|
}
|
|
|
|
public static int randomBetweenInclusive(RandomSource random, int min, int maxInclusive) {
|
|
return random.nextInt(maxInclusive - min + 1) + min;
|
|
}
|
|
|
|
public static float randomBetween(RandomSource random, float min, float maxExclusive) {
|
|
return random.nextFloat() * (maxExclusive - min) + min;
|
|
}
|
|
|
|
public static float normal(RandomSource random, float mean, float deviation) {
|
|
return mean + (float)random.nextGaussian() * deviation;
|
|
}
|
|
|
|
public static double lengthSquared(double x, double y) {
|
|
return x * x + y * y;
|
|
}
|
|
|
|
public static double length(double x, double y) {
|
|
return java.lang.Math.sqrt(Mth.lengthSquared(x, y));
|
|
}
|
|
|
|
public static float length(float x, float y) {
|
|
return (float)java.lang.Math.sqrt(Mth.lengthSquared(x, y));
|
|
}
|
|
|
|
public static double lengthSquared(double x, double y, double z) {
|
|
return x * x + y * y + z * z;
|
|
}
|
|
|
|
public static double length(double x, double y, double z) {
|
|
return java.lang.Math.sqrt(Mth.lengthSquared(x, y, z));
|
|
}
|
|
|
|
public static float lengthSquared(float x, float y, float z) {
|
|
return x * x + y * y + z * z;
|
|
}
|
|
|
|
public static int quantize(double value, int quantizeResolution) {
|
|
return Mth.floor(value / (double)quantizeResolution) * quantizeResolution;
|
|
}
|
|
|
|
public static IntStream outFromOrigin(int origin, int lowerBound, int upperBound) {
|
|
return Mth.outFromOrigin(origin, lowerBound, upperBound, 1);
|
|
}
|
|
|
|
public static IntStream outFromOrigin(int origin, int lowerBound, int upperBound, int stepSize) {
|
|
if (lowerBound > upperBound) {
|
|
throw new IllegalArgumentException(String.format(Locale.ROOT, "upperBound %d expected to be > lowerBound %d", upperBound, lowerBound));
|
|
}
|
|
if (stepSize < 1) {
|
|
throw new IllegalArgumentException(String.format(Locale.ROOT, "step size expected to be >= 1, was %d", stepSize));
|
|
}
|
|
int clampedOrigin = Mth.clamp(origin, lowerBound, upperBound);
|
|
return IntStream.iterate(clampedOrigin, cursor -> {
|
|
int currentDistance = java.lang.Math.abs(clampedOrigin - cursor);
|
|
return clampedOrigin - currentDistance >= lowerBound || clampedOrigin + currentDistance <= upperBound;
|
|
}, cursor -> {
|
|
int attemptedStep;
|
|
boolean canMovePositive;
|
|
boolean previousWasNegative = cursor <= clampedOrigin;
|
|
int currentDistance = java.lang.Math.abs(clampedOrigin - cursor);
|
|
boolean bl = canMovePositive = clampedOrigin + currentDistance + stepSize <= upperBound;
|
|
if (!(previousWasNegative && canMovePositive || (attemptedStep = clampedOrigin - currentDistance - (previousWasNegative ? stepSize : 0)) < lowerBound)) {
|
|
return attemptedStep;
|
|
}
|
|
return clampedOrigin + currentDistance + stepSize;
|
|
});
|
|
}
|
|
|
|
public static Quaternionf rotationAroundAxis(Vector3f axis, Quaternionf rotation, Quaternionf result) {
|
|
float projectedLength = axis.dot(rotation.x, rotation.y, rotation.z);
|
|
return result.set(axis.x * projectedLength, axis.y * projectedLength, axis.z * projectedLength, rotation.w).normalize();
|
|
}
|
|
|
|
public static int mulAndTruncate(Fraction fraction, int factor) {
|
|
return fraction.getNumerator() * factor / fraction.getDenominator();
|
|
}
|
|
|
|
static {
|
|
for (int ind = 0; ind < 257; ++ind) {
|
|
double v = (double)ind / 256.0;
|
|
double asinv = java.lang.Math.asin(v);
|
|
Mth.COS_TAB[ind] = java.lang.Math.cos(asinv);
|
|
Mth.ASIN_TAB[ind] = asinv;
|
|
}
|
|
}
|
|
}
|
|
|