ASCL Maths Class

package org.asassecreations.engine.tools.math;

import org.asassecreations.engine.component.Transform;
import org.asassecreations.engine.render.Camera;
import org.asassecreations.engine.render.Color;
import org.lwjgl.util.vector.Matrix4f;
import org.lwjgl.util.vector.Vector2f;
import org.lwjgl.util.vector.Vector3f;
import org.lwjgl.util.vector.Vector4f;

public final class Maths {

    private Maths() {

    }

    public static final float clampMin(final float value, final float min) {

        if (value <= min) return min;
        return value;

    }

    public static final float clampMax(final float value, final float max) {

        if (value >= max) return max;
        return value;

    }

    public static final float clamp(final float value, final float min, final float max) {

        return clampMin(clampMax(value, max), min);

    }

    public static final int clamp(final int value, final int min, final int max) {

        if (value >= max) return max;
        if (value <= min) return min;
        return value;

    }

    public static final float mix(final float a, final float b, final float percent) {

        return a * (1f - percent) + b * percent;

    }

    public static final Vector2f mix(final Vector2f a, final Vector2f b, final float percent) {

        return new Vector2f(mix(a.x, b.x, percent), mix(a.y, b.y, percent));

    }

    public static final Vector3f mix(final Vector3f a, final Vector3f b, final float percent) {

        return new Vector3f(mix(a.x, b.x, percent), mix(a.y, b.y, percent), mix(a.z, b.z, percent));

    }

    public static final Vector4f mix(final Vector4f a, final Vector4f b, final float percent) {

        return new Vector4f(mix(a.x, b.x, percent), mix(a.y, b.y, percent), mix(a.z, b.z, percent), mix(a.w, b.w, percent));

    }

    public static final Color mix(final Color a, final Color b, final float percent) {

        return new Color(mix(a.asVector4(), b.asVector4(), percent));

    }

    public static final float approach(final float current, final float goal, final float delta) {

        final float difference = goal - current;

        if (difference > delta) return current + delta;
        if (difference < -delta) return current - delta;

        return goal;

    }

    public static final float approachSmooth(final float current, final float goal, final float delta) {

        return approach(current, goal, positive(current - goal) * delta);

    }

    public static final float minMaxConvert(final float input, final float inputLow, final float inputHigh, final float outputLow, final float outputHigh) {

        return (input - inputLow) / (inputHigh - inputLow) * (outputHigh - outputLow) + outputLow;

    }

    public static final Matrix4f createTransformationMatrix(final Vector3f translation, final Vector3f rotation, final Vector3f scale) {

        final Matrix4f matrix = new Matrix4f();
        matrix.setIdentity();

        Matrix4f.translate(translation, matrix, matrix);
        Matrix4f.rotate((float) Math.toRadians(rotation.x), new Vector3f(1, 0, 0), matrix, matrix);
        Matrix4f.rotate((float) Math.toRadians(rotation.y), new Vector3f(0, 1, 0), matrix, matrix);
        Matrix4f.rotate((float) Math.toRadians(rotation.z), new Vector3f(0, 0, 1), matrix, matrix);
        Matrix4f.scale(scale, matrix, matrix);

        return matrix;

    }

    public static final Matrix4f createTransformationMatrix(final Transform transform) {

        return createTransformationMatrix(transform.position, transform.rotation, transform.scale);

    }

    public static final Matrix4f createViewMatrix(final Camera camera) {

        final Matrix4f matrix = new Matrix4f();
        matrix.setIdentity();

        Matrix4f.rotate((float) Math.toRadians(camera.rotation.x), new Vector3f(1, 0, 0), matrix, matrix);
        Matrix4f.rotate((float) Math.toRadians(camera.rotation.y), new Vector3f(0, 1, 0), matrix, matrix);
        Matrix4f.rotate((float) Math.toRadians(camera.rotation.z), new Vector3f(0, 0, 1), matrix, matrix);

        final Vector3f negative = new Vector3f(-camera.position.x, -camera.position.y, -camera.position.z);

        Matrix4f.translate(negative, matrix, matrix);

        return matrix;

    }

    public static final float barryCentric(final Vector3f p1, final Vector3f p2, final Vector3f p3, final Vector2f pos) {
        final float det = (p2.z - p3.z) * (p1.x - p3.x) + (p3.x - p2.x) * (p1.z - p3.z);
        final float l1 = ((p2.z - p3.z) * (pos.x - p3.x) + (p3.x - p2.x) * (pos.y - p3.z)) / det;
        final float l2 = ((p3.z - p1.z) * (pos.x - p3.x) + (p1.x - p3.x) * (pos.y - p3.z)) / det;
        final float l3 = 1.0f - l1 - l2;
        return l1 * p1.y + l2 * p2.y + l3 * p3.y;
    }

    public static final Matrix4f createProjectionMatrix(final float fov, final float nearPlane, final float farPlane, final int width, final int height) {

        final Matrix4f matrix = new Matrix4f();
        final float aspectRatio = (float) width / (float) height;
        final float y_scale = (float) (1f / Math.tan(Math.toRadians(fov / 2f)));
        final float x_scale = y_scale / aspectRatio;
        final float frustum_length = farPlane - nearPlane;

        matrix.m00 = x_scale;
        matrix.m11 = y_scale;
        matrix.m22 = -((farPlane + nearPlane) / frustum_length);
        matrix.m23 = -1;
        matrix.m32 = -(2 * nearPlane * farPlane / frustum_length);
        matrix.m33 = 0;

        return matrix;

    }

    public static final float positive(final float value) {

        return abs(value);

    }

    public static final float negative(final float value) {

        return -abs(value);

    }

    public static final float abs(final float value) {

        return value < 0 ? -value : value;

    }

    public static final float min(final float a, final float b) {

        return Math.min(a, b);

    }

    public static final float max(final float a, final float b) {

        return Math.max(a, b);

    }

    public static final Matrix4f createTransformationMatrix(final Vector2f translation, final Vector2f scale) {
        final Matrix4f matrix = new Matrix4f();
        matrix.setIdentity();
        Matrix4f.translate(translation, matrix, matrix);
        Matrix4f.scale(new Vector3f(scale.x, scale.y, 1f), matrix, matrix);
        return matrix;
    }

    public static final float hnsin(final float input) {

        return (float) Math.sin(Math.PI * input);

    }

    public static final float hncos(final float input) {

        return (float) Math.cos(Math.PI * input);

    }

    public static final float fnsin(final float input) {

        return (float) Math.sin(2f * Math.PI * input);

    }

    public static final float fncos(final float input) {

        return (float) Math.cos(2f * Math.PI * input);

    }

}