diff --git a/silk-core/src/main/kotlin/net/silkmc/silk/core/math/geometry/AABBExtensions.kt b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/geometry/AABBExtensions.kt new file mode 100644 index 00000000..98908f37 --- /dev/null +++ b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/geometry/AABBExtensions.kt @@ -0,0 +1,33 @@ +@file:Suppress("unused", "EXTENSION_SHADOWED_BY_MEMBER") + +package net.silkmc.silk.core.math.geometry + +import net.minecraft.core.BlockPos +import net.minecraft.core.Vec3i +import net.minecraft.world.phys.AABB +import net.minecraft.world.phys.Vec3 +import net.silkmc.silk.core.math.vector.unaryMinus +import org.joml.Vector3f + +fun AABB.inflate(value: Int): AABB = inflate(value.toDouble()) +fun AABB.inflate(value: Number): AABB = inflate(value.toDouble()) + +fun AABB.deflate(value: Int): AABB = deflate(value.toDouble()) +fun AABB.deflate(value: Number): AABB = deflate(value.toDouble()) + +fun AABB.expandTowards(x: Int, y: Int, z: Int): AABB = expandTowards(x.toDouble(), y.toDouble(), z.toDouble()) +fun AABB.expandTowards(x: Number, y: Number, z: Number): AABB = expandTowards(x.toDouble(), y.toDouble(), z.toDouble()) + +infix fun AABB.minmax(aabb: AABB): AABB = minmax(aabb) + +operator fun AABB.contains(aabb: AABB) = intersects(aabb) +operator fun AABB.contains(pos: Vec3i) = contains(pos.x.toDouble(), pos.y.toDouble(), pos.z.toDouble()) +operator fun AABB.contains(pos: Vec3) = contains(pos.x, pos.y, pos.z) + +operator fun AABB.plus(pos: BlockPos): AABB = move(pos) +operator fun AABB.plus(pos: Vec3): AABB = move(pos) +operator fun AABB.plus(pos: Vector3f): AABB = move(pos) + +operator fun AABB.minus(pos: BlockPos): AABB = move(-pos) +operator fun AABB.minus(pos: Vec3): AABB = move(-pos) +operator fun AABB.minus(pos: Vector3f): AABB = move(-pos) diff --git a/silk-core/src/main/kotlin/net/silkmc/silk/core/math/matrix/MatrixOperations.kt b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/matrix/MatrixOperations.kt new file mode 100644 index 00000000..f876007a --- /dev/null +++ b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/matrix/MatrixOperations.kt @@ -0,0 +1,230 @@ +@file:Suppress("unused") + +package net.silkmc.silk.core.math.matrix + +import org.joml.Matrix2d +import org.joml.Matrix2f +import org.joml.Matrix3d +import org.joml.Matrix3f +import org.joml.Matrix3x2d +import org.joml.Matrix3x2f +import org.joml.Matrix4d +import org.joml.Matrix4f +import org.joml.Matrix4x3d +import org.joml.Matrix4x3f +import org.joml.Vector2d +import org.joml.Vector2f +import org.joml.Vector3d +import org.joml.Vector3f +import org.joml.Vector4d +import org.joml.Vector4f + + +// Matrix2f operations + +operator fun Matrix2f.unaryMinus(): Matrix2f = Matrix2f(this).times(-1) + +operator fun Matrix2f.not(): Matrix2f = Matrix2f(this).invert() + +operator fun Matrix2f.plus(matrix: Matrix2f): Matrix2f = Matrix2f(this).add(matrix) + +operator fun Matrix2f.minus(matrix: Matrix2f): Matrix2f = Matrix2f(this).sub(matrix) + +operator fun Matrix2f.times(n: Int): Matrix2f = Matrix2f(this).scale(n.toFloat()) +operator fun Matrix2f.times(n: Long): Matrix2f = Matrix2f(this).scale(n.toFloat()) +operator fun Matrix2f.times(n: Float): Matrix2f = Matrix2f(this).scale(n) +operator fun Matrix2f.times(n: Double): Matrix2f = Matrix2f(this).scale(n.toFloat()) +operator fun Matrix2f.times(n: Number): Matrix2f = Matrix2f(this).scale(n.toFloat()) + +operator fun Int.times(matrix: Matrix2f): Matrix2f = Matrix2f(matrix).scale(this.toFloat()) +operator fun Long.times(matrix: Matrix2f): Matrix2f = Matrix2f(matrix).scale(this.toFloat()) +operator fun Float.times(matrix: Matrix2f): Matrix2f = Matrix2f(matrix).scale(this) +operator fun Double.times(matrix: Matrix2f): Matrix2f = Matrix2f(matrix).scale(this.toFloat()) +operator fun Number.times(matrix: Matrix2f): Matrix2f = Matrix2f(matrix).scale(this.toFloat()) + +operator fun Matrix2f.times(vec: Vector2f): Vector2f = Matrix2f(this).transform(vec) +operator fun Vector2f.times(matrix: Matrix2f): Vector2f = Matrix2f(matrix).transpose().transform(this) +operator fun Matrix2f.times(matrix: Matrix2f): Matrix2f = Matrix2f(this).mul(matrix) + + +// Matrix2d operations + +operator fun Matrix2d.unaryMinus(): Matrix2d = Matrix2d(this).times(-1) + +operator fun Matrix2d.not(): Matrix2d = Matrix2d(this).invert() + +operator fun Matrix2d.plus(matrix: Matrix2d): Matrix2d = Matrix2d(this).add(matrix) + +operator fun Matrix2d.minus(matrix: Matrix2d): Matrix2d = Matrix2d(this).sub(matrix) + +operator fun Matrix2d.times(n: Int): Matrix2d = Matrix2d(this).scale(n.toDouble()) +operator fun Matrix2d.times(n: Long): Matrix2d = Matrix2d(this).scale(n.toDouble()) +operator fun Matrix2d.times(n: Float): Matrix2d = Matrix2d(this).scale(n.toDouble()) +operator fun Matrix2d.times(n: Double): Matrix2d = Matrix2d(this).scale(n) +operator fun Matrix2d.times(n: Number): Matrix2d = Matrix2d(this).scale(n.toDouble()) + +operator fun Int.times(matrix: Matrix2d): Matrix2d = Matrix2d(matrix).scale(this.toDouble()) +operator fun Long.times(matrix: Matrix2d): Matrix2d = Matrix2d(matrix).scale(this.toDouble()) +operator fun Float.times(matrix: Matrix2d): Matrix2d = Matrix2d(matrix).scale(this.toDouble()) +operator fun Double.times(matrix: Matrix2d): Matrix2d = Matrix2d(matrix).scale(this) +operator fun Number.times(matrix: Matrix2d): Matrix2d = Matrix2d(matrix).scale(this.toDouble()) + +operator fun Matrix2d.times(vec: Vector2d): Vector2d = Matrix2d(this).transform(vec) +operator fun Vector2d.times(matrix: Matrix2d): Vector2d = Matrix2d(matrix).transpose().transform(this) +operator fun Matrix2d.times(matrix: Matrix2d): Matrix2d = Matrix2d(this).mul(matrix) + + +// Matrix3f operations + +operator fun Matrix3f.unaryMinus(): Matrix3f = Matrix3f(this).times(-1) + +operator fun Matrix3f.not(): Matrix3f = Matrix3f(this).invert() + +operator fun Matrix3f.plus(matrix: Matrix3f): Matrix3f = Matrix3f(this).add(matrix) + +operator fun Matrix3f.minus(matrix: Matrix3f): Matrix3f = Matrix3f(this).sub(matrix) + +operator fun Matrix3f.times(n: Int): Matrix3f = Matrix3f(this).scale(n.toFloat()) +operator fun Matrix3f.times(n: Long): Matrix3f = Matrix3f(this).scale(n.toFloat()) +operator fun Matrix3f.times(n: Float): Matrix3f = Matrix3f(this).scale(n) +operator fun Matrix3f.times(n: Double): Matrix3f = Matrix3f(this).scale(n.toFloat()) +operator fun Matrix3f.times(n: Number): Matrix3f = Matrix3f(this).scale(n.toFloat()) + +operator fun Int.times(matrix: Matrix3f): Matrix3f = Matrix3f(matrix).scale(this.toFloat()) +operator fun Long.times(matrix: Matrix3f): Matrix3f = Matrix3f(matrix).scale(this.toFloat()) +operator fun Float.times(matrix: Matrix3f): Matrix3f = Matrix3f(matrix).scale(this) +operator fun Double.times(matrix: Matrix3f): Matrix3f = Matrix3f(matrix).scale(this.toFloat()) +operator fun Number.times(matrix: Matrix3f): Matrix3f = Matrix3f(matrix).scale(this.toFloat()) + +operator fun Matrix3f.times(vec: Vector3f): Vector3f = Matrix3f(this).transform(vec) +operator fun Vector3f.times(matrix: Matrix3f): Vector3f = Matrix3f(matrix).transpose().transform(this) +operator fun Matrix3f.times(matrix: Matrix3f): Matrix3f = Matrix3f(this).mul(matrix) + + +// Matrix3d operations + +operator fun Matrix3d.unaryMinus(): Matrix3d = Matrix3d(this).times(-1) + +operator fun Matrix3d.not(): Matrix3d = Matrix3d(this).invert() + +operator fun Matrix3d.plus(matrix: Matrix3d): Matrix3d = Matrix3d(this).add(matrix) + +operator fun Matrix3d.minus(matrix: Matrix3d): Matrix3d = Matrix3d(this).sub(matrix) + +operator fun Matrix3d.times(n: Int): Matrix3d = Matrix3d(this).scale(n.toDouble()) +operator fun Matrix3d.times(n: Long): Matrix3d = Matrix3d(this).scale(n.toDouble()) +operator fun Matrix3d.times(n: Float): Matrix3d = Matrix3d(this).scale(n.toDouble()) +operator fun Matrix3d.times(n: Double): Matrix3d = Matrix3d(this).scale(n) +operator fun Matrix3d.times(n: Number): Matrix3d = Matrix3d(this).scale(n.toDouble()) + +operator fun Int.times(matrix: Matrix3d): Matrix3d = Matrix3d(matrix).scale(this.toDouble()) +operator fun Long.times(matrix: Matrix3d): Matrix3d = Matrix3d(matrix).scale(this.toDouble()) +operator fun Float.times(matrix: Matrix3d): Matrix3d = Matrix3d(matrix).scale(this.toDouble()) +operator fun Double.times(matrix: Matrix3d): Matrix3d = Matrix3d(matrix).scale(this) +operator fun Number.times(matrix: Matrix3d): Matrix3d = Matrix3d(matrix).scale(this.toDouble()) + +operator fun Matrix3d.times(vec: Vector3d): Vector3d = Matrix3d(this).transform(vec) +operator fun Vector3d.times(matrix: Matrix3d): Vector3d = Matrix3d(matrix).transpose().transform(this) +operator fun Matrix3d.times(matrix: Matrix3d): Matrix3d = Matrix3d(this).mul(matrix) + + +// Matrix3x2f operations + +operator fun Matrix3x2f.unaryMinus(): Matrix3x2f = Matrix3x2f(this).times(-1) + +operator fun Matrix3x2f.not(): Matrix3x2f = Matrix3x2f(this).invert() + +operator fun Matrix3x2f.times(n: Int): Matrix3x2f = Matrix3x2f(this).scale(n.toFloat()) +operator fun Matrix3x2f.times(n: Long): Matrix3x2f = Matrix3x2f(this).scale(n.toFloat()) +operator fun Matrix3x2f.times(n: Float): Matrix3x2f = Matrix3x2f(this).scale(n) +operator fun Matrix3x2f.times(n: Double): Matrix3x2f = Matrix3x2f(this).scale(n.toFloat()) +operator fun Matrix3x2f.times(n: Number): Matrix3x2f = Matrix3x2f(this).scale(n.toFloat()) + +operator fun Int.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(matrix).scale(this.toFloat()) +operator fun Long.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(matrix).scale(this.toFloat()) +operator fun Float.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(matrix).scale(this) +operator fun Double.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(matrix).scale(this.toFloat()) +operator fun Number.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(matrix).scale(this.toFloat()) + +operator fun Matrix3x2f.times(vec: Vector3f): Vector3f = Matrix3x2f(this).transform(vec) +operator fun Matrix3x2f.times(matrix: Matrix3x2f): Matrix3x2f = Matrix3x2f(this).mul(matrix) + + +// Matrix3x2d operations + +operator fun Matrix3x2d.unaryMinus(): Matrix3x2d = Matrix3x2d(this).times(-1) + +operator fun Matrix3x2d.not(): Matrix3x2d = Matrix3x2d(this).invert() + +operator fun Matrix3x2d.times(n: Int): Matrix3x2d = Matrix3x2d(this).scale(n.toDouble()) +operator fun Matrix3x2d.times(n: Long): Matrix3x2d = Matrix3x2d(this).scale(n.toDouble()) +operator fun Matrix3x2d.times(n: Float): Matrix3x2d = Matrix3x2d(this).scale(n.toDouble()) +operator fun Matrix3x2d.times(n: Double): Matrix3x2d = Matrix3x2d(this).scale(n) +operator fun Matrix3x2d.times(n: Number): Matrix3x2d = Matrix3x2d(this).scale(n.toDouble()) + +operator fun Int.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(matrix).scale(this.toDouble()) +operator fun Long.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(matrix).scale(this.toDouble()) +operator fun Float.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(matrix).scale(this.toDouble()) +operator fun Double.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(matrix).scale(this) +operator fun Number.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(matrix).scale(this.toDouble()) + +operator fun Matrix3x2d.times(vec: Vector3d): Vector3d = Matrix3x2d(this).transform(vec) +operator fun Matrix3x2d.times(matrix: Matrix3x2d): Matrix3x2d = Matrix3x2d(this).mul(matrix) + + +// Matrix4f operations + +operator fun Matrix4f.unaryMinus(): Matrix4f = Matrix4f().zero().sub(this) + +operator fun Matrix4f.not(): Matrix4f = Matrix4f(this).invert() + +operator fun Matrix4f.plus(matrix: Matrix4f): Matrix4f = Matrix4f(this).add(matrix) + +operator fun Matrix4f.minus(matrix: Matrix4f): Matrix4f = Matrix4f(this).sub(matrix) + +operator fun Matrix4f.times(vec: Vector4f): Vector4f = Matrix4f(this).transform(vec) +operator fun Vector4f.times(matrix: Matrix4f): Vector4f = Matrix4f(matrix).transpose().transform(this) +operator fun Matrix4f.times(matrix: Matrix4f): Matrix4f = Matrix4f(this).mul(matrix) + + +// Matrix4d operations + +operator fun Matrix4d.unaryMinus(): Matrix4d = Matrix4d().zero().sub(this) + +operator fun Matrix4d.not(): Matrix4d = Matrix4d(this).invert() + +operator fun Matrix4d.plus(matrix: Matrix4d): Matrix4d = Matrix4d(this).add(matrix) + +operator fun Matrix4d.minus(matrix: Matrix4d): Matrix4d = Matrix4d(this).sub(matrix) + +operator fun Matrix4d.times(vec: Vector4d): Vector4d = Matrix4d(this).transform(vec) +operator fun Vector4d.times(matrix: Matrix4d): Vector4d = Matrix4d(matrix).transpose().transform(this) +operator fun Matrix4d.times(matrix: Matrix4d): Matrix4d = Matrix4d(this).mul(matrix) + + +// Matrix4x3f operations + +operator fun Matrix4x3f.unaryMinus(): Matrix4x3f = Matrix4x3f().zero().sub(this) + +operator fun Matrix4x3f.not(): Matrix4x3f = Matrix4x3f(this).invert() + +operator fun Matrix4x3f.plus(matrix: Matrix4x3f): Matrix4x3f = Matrix4x3f(this).add(matrix) + +operator fun Matrix4x3f.minus(matrix: Matrix4x3f): Matrix4x3f = Matrix4x3f(this).sub(matrix) + +operator fun Matrix4x3f.times(vec: Vector4f): Vector4f = Matrix4x3f(this).transform(vec) +operator fun Matrix4x3f.times(matrix: Matrix4x3f): Matrix4x3f = Matrix4x3f(this).mul(matrix) + + +// Matrix4x3d operations + +operator fun Matrix4x3d.unaryMinus(): Matrix4x3d = Matrix4x3d().zero().sub(this) + +operator fun Matrix4x3d.not(): Matrix4x3d = Matrix4x3d(this).invert() + +operator fun Matrix4x3d.plus(matrix: Matrix4x3d): Matrix4x3d = Matrix4x3d(this).add(matrix) + +operator fun Matrix4x3d.minus(matrix: Matrix4x3d): Matrix4x3d = Matrix4x3d(this).sub(matrix) + +operator fun Matrix4x3d.times(vec: Vector4d): Vector4d = Matrix4x3d(this).transform(vec) +operator fun Matrix4x3d.times(matrix: Matrix4x3d): Matrix4x3d = Matrix4x3d(this).mul(matrix) diff --git a/silk-core/src/main/kotlin/net/silkmc/silk/core/math/vector/VectorOperations.kt b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/vector/VectorOperations.kt index c8ff3839..bad2fdae 100644 --- a/silk-core/src/main/kotlin/net/silkmc/silk/core/math/vector/VectorOperations.kt +++ b/silk-core/src/main/kotlin/net/silkmc/silk/core/math/vector/VectorOperations.kt @@ -1,77 +1,205 @@ +@file:Suppress("unused", "EXTENSION_SHADOWED_BY_MEMBER") + package net.silkmc.silk.core.math.vector +import net.minecraft.core.BlockPos import net.minecraft.core.Vec3i +import net.minecraft.world.phys.Vec2 import net.minecraft.world.phys.Vec3 +import org.joml.Vector2d +import org.joml.Vector2f +import org.joml.Vector2i +import org.joml.Vector3d +import org.joml.Vector3f +import org.joml.Vector3i +import kotlin.math.roundToInt + + +// Vector initialization + +fun blockPosOf(x: Int, y: Int, z: Int): BlockPos = BlockPos(x, y, z) +fun blockPosOf(vec: Vec3): BlockPos = BlockPos(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun blockPosOf(vec: Vector3i): BlockPos = BlockPos(vec.x, vec.y, vec.z) +fun blockPosOf(vec: Vector3f): BlockPos = BlockPos(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun blockPosOf(vec: Vector3d): BlockPos = BlockPos(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) + +fun vec3iOf(x: Int, y: Int, z: Int): Vec3i = Vec3i(x, y, z) +fun vec3iOf(vec: Vec3): Vec3i = Vec3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun vec3iOf(vec: Vector3i): Vec3i = Vec3i(vec.x, vec.y, vec.z) +fun vec3iOf(vec: Vector3f): Vec3i = Vec3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun vec3iOf(vec: Vector3d): Vec3i = Vec3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) + +fun vec3Of(x: Double, y: Double, z: Double): Vec3 = Vec3(x, y, z) +fun vec3Of(vec: Vec3i): Vec3 = Vec3(vec.x.toDouble(), vec.y.toDouble(), vec.z.toDouble()) +fun vec3Of(vec: Vector3i): Vec3 = Vec3(vec.x.toDouble(), vec.y.toDouble(), vec.z.toDouble()) +fun vec3Of(vec: Vector3f): Vec3 = Vec3(vec) +fun vec3Of(vec: Vector3d): Vec3 = Vec3(vec.x, vec.y, vec.z) + +fun vector3iOf(x: Int, y: Int, z: Int): Vector3i = Vector3i(x, y, z) +fun vector3iOf(vec: Vec3i): Vector3i = Vector3i(vec.x, vec.y, vec.z) +fun vector3iOf(vec: Vec3): Vector3i = Vector3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun vector3iOf(vec: Vector3i): Vector3i = Vector3i(vec) // copy constructor +fun vector3iOf(vec: Vector3f): Vector3i = Vector3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) +fun vector3iOf(vec: Vector3d): Vector3i = Vector3i(vec.x.roundToInt(), vec.y.roundToInt(), vec.z.roundToInt()) + +fun vector3fOf(x: Float, y: Float, z: Float): Vector3f = Vector3f(x, y, z) +fun vector3fOf(vec: Vec3i): Vector3f = Vector3f(vec.x.toFloat(), vec.y.toFloat(), vec.z.toFloat()) +fun vector3fOf(vec: Vec3): Vector3f = Vector3f(vec.x.toFloat(), vec.y.toFloat(), vec.z.toFloat()) +fun vector3fOf(vec: Vector3i): Vector3f = Vector3f(vec) +fun vector3fOf(vec: Vector3f): Vector3f = Vector3f(vec) // copy constructor +fun vector3fOf(vec: Vector3d): Vector3f = Vector3f().set(vec) + +fun vector3dOf(x: Double, y: Double, z: Double): Vector3d = Vector3d(x, y, z) +fun vector3dOf(vec: Vec3i): Vector3d = Vector3d(vec.x.toDouble(), vec.y.toDouble(), vec.z.toDouble()) +fun vector3dOf(vec: Vec3): Vector3d = Vector3d(vec.x, vec.y, vec.z) +fun vector3dOf(vec: Vector3i): Vector3d = Vector3d(vec) +fun vector3dOf(vec: Vector3f): Vector3d = Vector3d(vec) +fun vector3dOf(vec: Vector3d): Vector3d = Vector3d(vec) // copy constructor + + +fun vec2Of(x: Float, y: Float): Vec2 = Vec2(x, y) +fun vec2Of(vec: Vector2i): Vec2 = Vec2(vec.x.toFloat(), vec.y.toFloat()) +fun vec2Of(vec: Vector2f): Vec2 = Vec2(vec.x, vec.y) +fun vec2Of(vec: Vector2d): Vec2 = Vec2(vec.x.toFloat(), vec.y.toFloat()) + +fun vector2iOf(x: Int, y: Int): Vector2i = Vector2i(x, y) +fun vector2iOf(vec: Vec2): Vector2i = Vector2i(vec.x.roundToInt(), vec.y.roundToInt()) +fun vector2iOf(vec: Vector2i): Vector2i = Vector2i(vec) // copy constructor +fun vector2iOf(vec: Vector2f): Vector2i = Vector2i(vec.x.roundToInt(), vec.y.roundToInt()) +fun vector2iOf(vec: Vector2d): Vector2i = Vector2i(vec.x.roundToInt(), vec.y.roundToInt()) + +fun vector2fOf(x: Float, y: Float): Vector2f = Vector2f(x, y) +fun vector2fOf(vec: Vec2): Vector2f = Vector2f(vec.x, vec.y) +fun vector2fOf(vec: Vector2i): Vector2f = Vector2f(vec) +fun vector2fOf(vec: Vector2f): Vector2f = Vector2f(vec) // copy constructor +fun vector2fOf(vec: Vector2d): Vector2f = Vector2f().set(vec) + + +fun vector2dOf(x: Double, y: Double): Vector2d = Vector2d(x, y) +fun vector2dOf(vec: Vec2): Vector2d = Vector2d(vec.x.toDouble(), vec.y.toDouble()) +fun vector2dOf(vec: Vector2i): Vector2d = Vector2d(vec) +fun vector2dOf(vec: Vector2f): Vector2d = Vector2d(vec) +fun vector2dOf(vec: Vector2d): Vector2d = Vector2d(vec) // copy constructor + + +// Vec3 operations -operator fun Vec3.not(): Vec3 = - reverse() +operator fun Vec3.unaryMinus(): Vec3 = reverse() -operator fun Vec3.plus(n: Number): Vec3 = - n.toDouble().let { nDouble -> add(nDouble, nDouble, nDouble) } +operator fun Vec3.not(): Vec3 = reverse() -operator fun Vec3.minus(n: Number): Vec3 = - n.toDouble().let { nDouble -> subtract(nDouble, nDouble, nDouble) } +operator fun Vec3.plus(n: Int): Vec3 = n.toDouble().let { nDouble -> add(nDouble, nDouble, nDouble) } +operator fun Vec3.plus(n: Long): Vec3 = n.toDouble().let { nDouble -> add(nDouble, nDouble, nDouble) } +operator fun Vec3.plus(n: Float): Vec3 = n.toDouble().let { nDouble -> add(nDouble, nDouble, nDouble) } +operator fun Vec3.plus(n: Double): Vec3 = n.let { nDouble -> add(nDouble, nDouble, nDouble) } +operator fun Vec3.plus(n: Number): Vec3 = n.toDouble().let { nDouble -> add(nDouble, nDouble, nDouble) } -operator fun Vec3.times(n: Number): Vec3 = - scale(n.toDouble()) +operator fun Vec3.minus(n: Int): Vec3 = n.toDouble().let { nDouble -> subtract(nDouble, nDouble, nDouble) } +operator fun Vec3.minus(n: Long): Vec3 = n.toDouble().let { nDouble -> subtract(nDouble, nDouble, nDouble) } +operator fun Vec3.minus(n: Float): Vec3 = n.toDouble().let { nDouble -> subtract(nDouble, nDouble, nDouble) } +operator fun Vec3.minus(n: Double): Vec3 = n.let { nDouble -> subtract(nDouble, nDouble, nDouble) } +operator fun Vec3.minus(n: Number): Vec3 = n.toDouble().let { nDouble -> subtract(nDouble, nDouble, nDouble) } -operator fun Vec3.div(n: Number): Vec3 = - scale(1.0 / n.toDouble()) +operator fun Vec3.times(n: Int): Vec3 = scale(n.toDouble()) +operator fun Vec3.times(n: Long): Vec3 = scale(n.toDouble()) +operator fun Vec3.times(n: Float): Vec3 = scale(n.toDouble()) +operator fun Vec3.times(n: Double): Vec3 = scale(n) +operator fun Vec3.times(n: Number): Vec3 = scale(n.toDouble()) -operator fun Vec3.compareTo(n: Number) = - length().compareTo(n.toDouble()) +operator fun Vec3.div(n: Int): Vec3 = scale(1.0 / n.toDouble()) +operator fun Vec3.div(n: Long): Vec3 = scale(1.0 / n.toDouble()) +operator fun Vec3.div(n: Float): Vec3 = scale(1.0 / n.toDouble()) +operator fun Vec3.div(n: Double): Vec3 = scale(1.0 / n) +operator fun Vec3.div(n: Number): Vec3 = scale(1.0 / n.toDouble()) -operator fun Vec3.plus(vec: Vec3): Vec3 = - add(vec) +operator fun Vec3.compareTo(n: Int) = length().compareTo(n) +operator fun Vec3.compareTo(n: Long) = length().compareTo(n) +operator fun Vec3.compareTo(n: Float) = length().compareTo(n) +operator fun Vec3.compareTo(n: Double) = length().compareTo(n) +operator fun Vec3.compareTo(n: Number) = length().compareTo(n.toDouble()) -operator fun Vec3.minus(vec: Vec3): Vec3 = - subtract(vec) +operator fun Vec3.plus(vec: Vec3): Vec3 = add(vec) -operator fun Vec3.times(vec: Vec3): Vec3 = - multiply(vec) +operator fun Vec3.minus(vec: Vec3): Vec3 = subtract(vec) -operator fun Vec3.div(vec: Vec3): Vec3 = - Vec3(x / vec.x, y / vec.y, z / vec.z) +operator fun Vec3.times(vec: Vec3): Vec3 = multiply(vec) + +operator fun Vec3.div(vec: Vec3): Vec3 = Vec3(x / vec.x, y / vec.y, z / vec.z) + +infix fun Vec3.cross(vec: Vec3): Vec3 = cross(vec) + +infix fun Vec3.dot(vec: Vec3): Double = dot(vec) @Suppress("DeprecatedCallableAddReplaceWith") // a "replace with" quick-fix could be confusing here @Deprecated(message = "This comparison is unintuitive and should be avoided") -operator fun Vec3.compareTo(vec: Vec3) = - lengthSqr().compareTo(vec.lengthSqr()) +operator fun Vec3.compareTo(vec: Vec3) = lengthSqr().compareTo(vec.lengthSqr()) operator fun Vec3.component1() = x operator fun Vec3.component2() = y operator fun Vec3.component3() = z -operator fun Vec3i.not(): Vec3i = - times(-1) +// Vec3i/BlockPos operations + +inline operator fun T.unaryMinus(): T = times(-1) + +inline operator fun T.not(): T = times(-1) -inline operator fun T.plus(n: Number): T = - n.toInt().let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.plus(n: Int): T = n.let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.plus(n: Long): T = n.toInt().let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.plus(n: Float): T = n.toInt().let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.plus(n: Double): T = n.toInt().let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.plus(n: Number): T = n.toInt().let { nInt -> offset(nInt, nInt, nInt) } as T -inline operator fun T.minus(n: Number): T = - (-n.toInt()).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.minus(n: Int): T = (-n).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.minus(n: Long): T = (-n.toInt()).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.minus(n: Float): T = (-n.toInt()).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.minus(n: Double): T = (-n.toInt()).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.minus(n: Number): T = (-n.toInt()).let { nInt -> offset(nInt, nInt, nInt) } as T +inline operator fun T.times(n: Int): T = multiply(n) as T +inline operator fun T.times(n: Long): T = multiply(n.toInt()) as T +operator fun Vec3i.times(n: Float): Vec3i = Vec3i((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) +operator fun Vec3i.times(n: Double): Vec3i = Vec3i((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) operator fun Vec3i.times(n: Number): Vec3i = - multiply(n.toInt()) + n.toDouble().let { nDouble -> Vec3i((x * nDouble).toInt(), (y * nDouble).toInt(), (z * nDouble).toInt()) } + +operator fun BlockPos.times(n: Float): BlockPos = BlockPos((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) +operator fun BlockPos.times(n: Double): BlockPos = BlockPos((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) +operator fun BlockPos.times(n: Number): BlockPos = + n.toDouble().let { nDouble -> BlockPos((x * nDouble).toInt(), (y * nDouble).toInt(), (z * nDouble).toInt()) } + +operator fun Vec3i.div(n: Int): Vec3i = times(1.0 / n.toDouble()) +operator fun Vec3i.div(n: Long): Vec3i = times(1.0 / n.toDouble()) +operator fun Vec3i.div(n: Float): Vec3i = times(1.0 / n.toDouble()) +operator fun Vec3i.div(n: Double): Vec3i = times(1.0 / n) +operator fun Vec3i.div(n: Number): Vec3i = times(1.0 / n.toDouble()) + +operator fun BlockPos.div(n: Int): BlockPos = times(1.0 / n.toDouble()) +operator fun BlockPos.div(n: Long): BlockPos = times(1.0 / n.toDouble()) +operator fun BlockPos.div(n: Float): BlockPos = times(1.0 / n.toDouble()) +operator fun BlockPos.div(n: Double): BlockPos = times(1.0 / n) +operator fun BlockPos.div(n: Number): BlockPos = times(1.0 / n.toDouble()) + +operator fun Vec3i.compareTo(n: Int) = vec3Of(this).length().compareTo(n) +operator fun Vec3i.compareTo(n: Long) = vec3Of(this).length().compareTo(n) +operator fun Vec3i.compareTo(n: Float) = vec3Of(this).length().compareTo(n) +operator fun Vec3i.compareTo(n: Double) = vec3Of(this).length().compareTo(n) +operator fun Vec3i.compareTo(n: Number) = vec3Of(this).length().compareTo(n.toDouble()) -operator fun Vec3i.div(n: Number) = - (1.0 / n.toDouble()).let { nDouble -> Vec3i((x * nDouble).toInt(), (y * nDouble).toInt(), (z * nDouble).toInt()) } +inline operator fun T.plus(vec: Vec3i): T = offset(vec) as T -operator fun Vec3i.compareTo(n: Number) = - Vec3(x.toDouble(), y.toDouble(), z.toDouble()).length().compareTo(n.toDouble()) +inline operator fun T.minus(vec: Vec3i): T = offset(!vec) as T -inline operator fun T.plus(vec: Vec3i): T = - offset(vec) as T +operator fun Vec3i.times(vec: Vec3i): Vec3i = Vec3i(x * vec.x, y * vec.y, z * vec.z) +operator fun BlockPos.times(vec: Vec3i): BlockPos = BlockPos(x * vec.x, y * vec.y, z * vec.z) -inline operator fun T.minus(vec: Vec3i): T = - offset(!vec) as T +operator fun Vec3i.div(vec: Vec3i): Vec3i = Vec3i(x / vec.x, y / vec.y, z / vec.z) +operator fun BlockPos.div(vec: Vec3i): BlockPos = BlockPos(x / vec.x, y / vec.y, z / vec.z) -operator fun Vec3i.times(vec: Vec3i): Vec3i = - Vec3i(x * vec.x, y * vec.y, z * vec.z) +inline infix fun T.cross(vec: Vec3i): T = cross(vec) as T -operator fun Vec3i.div(vec: Vec3i): Vec3i = - Vec3i(x / vec.x, y / vec.y, z / vec.z) +inline infix fun T.dot(vec: Vec3i): Double = ((x * vec.x) + (y * vec.y) + (z * vec.z)).toDouble() // there is an internal compareTo function // operator fun Vec3i.compareTo(vec: Vec3i) = ... @@ -79,3 +207,363 @@ operator fun Vec3i.div(vec: Vec3i): Vec3i = operator fun Vec3i.component1() = x operator fun Vec3i.component2() = y operator fun Vec3i.component3() = z + + +// Vector3i operations + +operator fun Vector3i.unaryMinus(): Vector3i = Vector3i(this).mul(-1) + +operator fun Vector3i.not(): Vector3i = Vector3i(this).mul(-1) + +operator fun Vector3i.plus(n: Int): Vector3i = n.let { nInt -> Vector3i(this).add(nInt, nInt, nInt) } +operator fun Vector3i.plus(n: Long): Vector3i = n.toInt().let { nInt -> Vector3i(this).add(nInt, nInt, nInt) } +operator fun Vector3i.plus(n: Float): Vector3i = n.toInt().let { nInt -> Vector3i(this).add(nInt, nInt, nInt) } +operator fun Vector3i.plus(n: Double): Vector3i = n.toInt().let { nInt -> Vector3i(this).add(nInt, nInt, nInt) } +operator fun Vector3i.plus(n: Number): Vector3i = n.toInt().let { nInt -> Vector3i(this).add(nInt, nInt, nInt) } + +operator fun Vector3i.minus(n: Int): Vector3i = n.let { nInt -> Vector3i(this).sub(nInt, nInt, nInt) } +operator fun Vector3i.minus(n: Long): Vector3i = n.toInt().let { nInt -> Vector3i(this).sub(nInt, nInt, nInt) } +operator fun Vector3i.minus(n: Float): Vector3i = n.toInt().let { nInt -> Vector3i(this).sub(nInt, nInt, nInt) } +operator fun Vector3i.minus(n: Double): Vector3i = n.toInt().let { nInt -> Vector3i(this).sub(nInt, nInt, nInt) } +operator fun Vector3i.minus(n: Number): Vector3i = n.toInt().let { nInt -> Vector3i(this).sub(nInt, nInt, nInt) } + +operator fun Vector3i.times(n: Int): Vector3i = Vector3i(this).mul(n) +operator fun Vector3i.times(n: Long): Vector3i = Vector3i(this).mul(n.toInt()) +operator fun Vector3i.times(n: Float): Vector3i = Vector3i((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) +operator fun Vector3i.times(n: Double): Vector3i = Vector3i((x * n).toInt(), (y * n).toInt(), (z * n).toInt()) +operator fun Vector3i.times(n: Number): Vector3i = + n.toDouble().let { nDouble -> Vector3i((x * nDouble).toInt(), (y * nDouble).toInt(), (z * nDouble).toInt()) } + +operator fun Vector3i.div(n: Int): Vector3i = Vector3i(this).div(n) +operator fun Vector3i.div(n: Long): Vector3i = Vector3i(this).div(n.toInt()) +operator fun Vector3i.div(n: Float): Vector3i = Vector3i(this).div(n) +operator fun Vector3i.div(n: Double): Vector3i = Vector3i(this).div(n.toFloat()) +operator fun Vector3i.div(n: Number): Vector3i = Vector3i(this).div(n.toFloat()) + +operator fun Vector3i.compareTo(n: Int) = length().compareTo(n) +operator fun Vector3i.compareTo(n: Long) = length().compareTo(n) +operator fun Vector3i.compareTo(n: Float) = length().compareTo(n) +operator fun Vector3i.compareTo(n: Double) = length().compareTo(n) +operator fun Vector3i.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector3i.plus(vec: Vector3i): Vector3i = Vector3i(this).add(vec) + +operator fun Vector3i.minus(vec: Vector3i): Vector3i = Vector3i(this).sub(vec) + +operator fun Vector3i.times(vec: Vector3i): Vector3i = Vector3i(this).mul(vec) + +operator fun Vector3i.div(vec: Vector3i): Vector3i = Vector3i(x / vec.x, y / vec.y, z / vec.z) + +infix fun Vector3i.cross(vec: Vector3i): Vector3i = Vector3i(y * vec.z - z * vec.y, z * vec.x - x * vec.z, x * vec.y - y * vec.x) + +infix fun Vector3i.dot(vec: Vector3i): Double = ((x * vec.x) + (y * vec.y) + (z * vec.z)).toDouble() + +operator fun Vector3i.component1() = x +operator fun Vector3i.component2() = y +operator fun Vector3i.component3() = z + + +// Vector3f operations + +operator fun Vector3f.unaryMinus(): Vector3f = Vector3f(this).mul(-1.0f) + +operator fun Vector3f.not(): Vector3f = Vector3f(this).mul(-1.0f) + +operator fun Vector3f.plus(n: Int): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).add(nFloat, nFloat, nFloat) } +operator fun Vector3f.plus(n: Long): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).add(nFloat, nFloat, nFloat) } +operator fun Vector3f.plus(n: Float): Vector3f = Vector3f(this).add(n, n, n) +operator fun Vector3f.plus(n: Double): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).add(nFloat, nFloat, nFloat) } +operator fun Vector3f.plus(n: Number): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).add(nFloat, nFloat, nFloat) } + +operator fun Vector3f.minus(n: Int): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).sub(nFloat, nFloat, nFloat) } +operator fun Vector3f.minus(n: Long): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).sub(nFloat, nFloat, nFloat) } +operator fun Vector3f.minus(n: Float): Vector3f = Vector3f(this).sub(n, n, n) +operator fun Vector3f.minus(n: Double): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).sub(nFloat, nFloat, nFloat) } +operator fun Vector3f.minus(n: Number): Vector3f = n.toFloat().let { nFloat -> Vector3f(this).sub(nFloat, nFloat, nFloat) } + +operator fun Vector3f.times(n: Int): Vector3f = Vector3f(this).mul(n.toFloat()) +operator fun Vector3f.times(n: Long): Vector3f = Vector3f(this).mul(n.toFloat()) +operator fun Vector3f.times(n: Float): Vector3f = Vector3f(this).mul(n) +operator fun Vector3f.times(n: Double): Vector3f = Vector3f(this).mul(n.toFloat()) +operator fun Vector3f.times(n: Number): Vector3f = Vector3f(this).mul(n.toFloat()) + +operator fun Vector3f.div(n: Int): Vector3f = Vector3f(this).div(n.toFloat()) +operator fun Vector3f.div(n: Long): Vector3f = Vector3f(this).div(n.toFloat()) +operator fun Vector3f.div(n: Float): Vector3f = Vector3f(this).div(n) +operator fun Vector3f.div(n: Double): Vector3f = Vector3f(this).div(n.toFloat()) +operator fun Vector3f.div(n: Number): Vector3f = Vector3f(this).div(n.toFloat()) + +operator fun Vector3f.compareTo(n: Int) = length().compareTo(n) +operator fun Vector3f.compareTo(n: Long) = length().compareTo(n) +operator fun Vector3f.compareTo(n: Float) = length().compareTo(n) +operator fun Vector3f.compareTo(n: Double) = length().compareTo(n) +operator fun Vector3f.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector3f.plus(vec: Vector3f): Vector3f = Vector3f(this).add(vec) + +operator fun Vector3f.minus(vec: Vector3f): Vector3f = Vector3f(this).sub(vec) + +operator fun Vector3f.times(vec: Vector3f): Vector3f = Vector3f(this).mul(vec) + +operator fun Vector3f.div(vec: Vector3f): Vector3f = Vector3f(this).div(vec) + +infix fun Vector3f.cross(vec: Vector3f): Vector3f = Vector3f(this).cross(vec) + +infix fun Vector3f.dot(vec: Vector3f): Float = Vector3f(this).dot(vec) + +operator fun Vector3f.component1() = x +operator fun Vector3f.component2() = y +operator fun Vector3f.component3() = z + + +// Vector3d operations + +operator fun Vector3d.unaryMinus(): Vector3d = Vector3d(this).mul(-1.0) + +operator fun Vector3d.not(): Vector3d = Vector3d(this).mul(-1.0) + +operator fun Vector3d.plus(n: Int): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).add(nDouble, nDouble, nDouble) } +operator fun Vector3d.plus(n: Long): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).add(nDouble, nDouble, nDouble) } +operator fun Vector3d.plus(n: Float): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).add(nDouble, nDouble, nDouble) } +operator fun Vector3d.plus(n: Double): Vector3d = Vector3d(this).add(n, n, n) +operator fun Vector3d.plus(n: Number): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).add(nDouble, nDouble, nDouble) } + +operator fun Vector3d.minus(n: Int): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).sub(nDouble, nDouble, nDouble) } +operator fun Vector3d.minus(n: Long): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).sub(nDouble, nDouble, nDouble) } +operator fun Vector3d.minus(n: Float): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).sub(nDouble, nDouble, nDouble) } +operator fun Vector3d.minus(n: Double): Vector3d = Vector3d(this).sub(n, n, n) +operator fun Vector3d.minus(n: Number): Vector3d = n.toDouble().let { nDouble -> Vector3d(this).sub(nDouble, nDouble, nDouble) } + +operator fun Vector3d.times(n: Int): Vector3d = Vector3d(this).mul(n.toDouble()) +operator fun Vector3d.times(n: Long): Vector3d = Vector3d(this).mul(n.toDouble()) +operator fun Vector3d.times(n: Float): Vector3d = Vector3d(this).mul(n.toDouble()) +operator fun Vector3d.times(n: Double): Vector3d = Vector3d(this).mul(n) +operator fun Vector3d.times(n: Number): Vector3d = Vector3d(this).mul(n.toDouble()) + +operator fun Vector3d.div(n: Int): Vector3d = Vector3d(this).div(n.toDouble()) +operator fun Vector3d.div(n: Long): Vector3d = Vector3d(this).div(n.toDouble()) +operator fun Vector3d.div(n: Float): Vector3d = Vector3d(this).div(n.toDouble()) +operator fun Vector3d.div(n: Double): Vector3d = Vector3d(this).div(n) +operator fun Vector3d.div(n: Number): Vector3d = Vector3d(this).div(n.toDouble()) + +operator fun Vector3d.compareTo(n: Int) = length().compareTo(n) +operator fun Vector3d.compareTo(n: Long) = length().compareTo(n) +operator fun Vector3d.compareTo(n: Float) = length().compareTo(n) +operator fun Vector3d.compareTo(n: Double) = length().compareTo(n) +operator fun Vector3d.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector3d.plus(vec: Vector3d): Vector3d = Vector3d(this).add(vec) + +operator fun Vector3d.minus(vec: Vector3d): Vector3d = Vector3d(this).sub(vec) + +operator fun Vector3d.times(vec: Vector3d): Vector3d = Vector3d(this).mul(vec) + +operator fun Vector3d.div(vec: Vector3d): Vector3d = Vector3d(this).div(vec) + +infix fun Vector3d.cross(vec: Vector3d): Vector3d = Vector3d(this).cross(vec) + +infix fun Vector3d.dot(vec: Vector3d): Double = Vector3d(this).dot(vec) + +operator fun Vector3d.component1() = x +operator fun Vector3d.component2() = y +operator fun Vector3d.component3() = z + + +// Vec2 operations + +operator fun Vec2.unaryMinus(): Vec2 = negated() + +operator fun Vec2.not(): Vec2 = negated() + +operator fun Vec2.plus(n: Int): Vec2 = add(n.toFloat()) +operator fun Vec2.plus(n: Long): Vec2 = add(n.toFloat()) +operator fun Vec2.plus(n: Float): Vec2 = add(n) +operator fun Vec2.plus(n: Double): Vec2 = add(n.toFloat()) +operator fun Vec2.plus(n: Number): Vec2 = add(n.toFloat()) + +operator fun Vec2.minus(n: Int): Vec2 = plus(-n) +operator fun Vec2.minus(n: Long): Vec2 = plus(-n) +operator fun Vec2.minus(n: Float): Vec2 = plus(-n) +operator fun Vec2.minus(n: Double): Vec2 = plus(-n) +operator fun Vec2.minus(n: Number): Vec2 = plus(-n.toDouble()) + +operator fun Vec2.times(n: Int): Vec2 = scale(n.toFloat()) +operator fun Vec2.times(n: Long): Vec2 = scale(n.toFloat()) +operator fun Vec2.times(n: Float): Vec2 = scale(n) +operator fun Vec2.times(n: Double): Vec2 = scale(n.toFloat()) +operator fun Vec2.times(n: Number): Vec2 = scale(n.toFloat()) + +operator fun Vec2.div(n: Int): Vec2 = scale(1.0f / n.toFloat()) +operator fun Vec2.div(n: Long): Vec2 = scale(1.0f / n.toFloat()) +operator fun Vec2.div(n: Float): Vec2 = scale(1.0f / n) +operator fun Vec2.div(n: Double): Vec2 = scale(1.0f / n.toFloat()) +operator fun Vec2.div(n: Number): Vec2 = scale(1.0f / n.toFloat()) + +operator fun Vec2.compareTo(n: Int) = length().compareTo(n) +operator fun Vec2.compareTo(n: Long) = length().compareTo(n) +operator fun Vec2.compareTo(n: Float) = length().compareTo(n) +operator fun Vec2.compareTo(n: Double) = length().compareTo(n) +operator fun Vec2.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vec2.plus(vec: Vec2): Vec2 = add(vec) + +operator fun Vec2.minus(vec: Vec2): Vec2 = add(-vec) + +operator fun Vec2.times(vec: Vec2): Vec2 = Vec2(x * vec.x, y * vec.y) + +operator fun Vec2.div(vec: Vec2): Vec2 = Vec2(x / vec.x, y / vec.y) + +infix fun Vec2.dot(vec: Vec2): Float = dot(vec) + +operator fun Vec2.component1() = x +operator fun Vec2.component2() = y + + +// Vector2i operations + +operator fun Vector2i.unaryMinus(): Vector2i = Vector2i(this).mul(-1) + +operator fun Vector2i.not(): Vector2i = Vector2i(this).mul(-1) + +operator fun Vector2i.plus(n: Int): Vector2i = Vector2i(this).add(n, n) +operator fun Vector2i.plus(n: Long): Vector2i = n.toInt().let { nInt -> Vector2i(this).add(nInt, nInt) } +operator fun Vector2i.plus(n: Float): Vector2i = n.toInt().let { nInt -> Vector2i(this).add(nInt, nInt) } +operator fun Vector2i.plus(n: Double): Vector2i = n.toInt().let { nInt -> Vector2i(this).add(nInt, nInt) } +operator fun Vector2i.plus(n: Number): Vector2i = n.toInt().let { nInt -> Vector2i(this).add(nInt, nInt) } + +operator fun Vector2i.minus(n: Int): Vector2i = Vector2i(this).sub(n, n) +operator fun Vector2i.minus(n: Long): Vector2i = n.toInt().let { nInt -> Vector2i(this).sub(nInt, nInt) } +operator fun Vector2i.minus(n: Float): Vector2i = n.toInt().let { nInt -> Vector2i(this).sub(nInt, nInt) } +operator fun Vector2i.minus(n: Double): Vector2i = n.toInt().let { nInt -> Vector2i(this).sub(nInt, nInt) } +operator fun Vector2i.minus(n: Number): Vector2i = n.toInt().let { nInt -> Vector2i(this).sub(nInt, nInt) } + +operator fun Vector2i.times(n: Int): Vector2i = Vector2i(this).mul(n) +operator fun Vector2i.times(n: Long): Vector2i = Vector2i(this).mul(n.toInt()) +operator fun Vector2i.times(n: Float): Vector2i = n.toDouble().let { nDouble -> Vector2i((x * nDouble).toInt(), (y * nDouble).toInt()) } +operator fun Vector2i.times(n: Double): Vector2i = Vector2i((x * n).toInt(), (y * n).toInt()) +operator fun Vector2i.times(n: Number): Vector2i = n.toDouble().let { nDouble -> Vector2i((x * nDouble).toInt(), (y * nDouble).toInt()) } + +operator fun Vector2i.div(n: Int): Vector2i = Vector2i(this).div(n) +operator fun Vector2i.div(n: Long): Vector2i = Vector2i(this).div(n.toInt()) +operator fun Vector2i.div(n: Float): Vector2i = Vector2i(this).div(n) +operator fun Vector2i.div(n: Double): Vector2i = Vector2i(this).div(n.toFloat()) +operator fun Vector2i.div(n: Number): Vector2i = Vector2i(this).div(n.toFloat()) + +operator fun Vector2i.compareTo(n: Int) = length().compareTo(n) +operator fun Vector2i.compareTo(n: Long) = length().compareTo(n) +operator fun Vector2i.compareTo(n: Float) = length().compareTo(n) +operator fun Vector2i.compareTo(n: Double) = length().compareTo(n) +operator fun Vector2i.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector2i.plus(vec: Vector2i): Vector2i = Vector2i(this).add(vec) + +operator fun Vector2i.minus(vec: Vector2i): Vector2i = Vector2i(this).sub(vec) + +operator fun Vector2i.times(vec: Vector2i): Vector2i = Vector2i(this).mul(vec) + +operator fun Vector2i.div(vec: Vector2i): Vector2i = Vector2i(x / vec.x, y / vec.y) + +infix fun Vector2i.dot(vec: Vector2i): Double = ((x * vec.x) + (y * vec.y)).toDouble() + +operator fun Vector2i.component1() = x +operator fun Vector2i.component2() = y + + +// Vector2f operations + +operator fun Vector2f.unaryMinus(): Vector2f = Vector2f(this).mul(-1.0f) + +operator fun Vector2f.not(): Vector2f = Vector2f(this).mul(-1.0f) + +operator fun Vector2f.plus(n: Int): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).add(nFloat, nFloat) } +operator fun Vector2f.plus(n: Long): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).add(nFloat, nFloat) } +operator fun Vector2f.plus(n: Float): Vector2f = Vector2f(this).add(n, n) +operator fun Vector2f.plus(n: Double): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).add(nFloat, nFloat) } +operator fun Vector2f.plus(n: Number): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).add(nFloat, nFloat) } + +operator fun Vector2f.minus(n: Int): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).sub(nFloat, nFloat) } +operator fun Vector2f.minus(n: Long): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).sub(nFloat, nFloat) } +operator fun Vector2f.minus(n: Float): Vector2f = Vector2f(this).sub(n, n) +operator fun Vector2f.minus(n: Double): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).sub(nFloat, nFloat) } +operator fun Vector2f.minus(n: Number): Vector2f = n.toFloat().let { nFloat -> Vector2f(this).sub(nFloat, nFloat) } + +operator fun Vector2f.times(n: Int): Vector2f = Vector2f(this).mul(n.toFloat()) +operator fun Vector2f.times(n: Long): Vector2f = Vector2f(this).mul(n.toFloat()) +operator fun Vector2f.times(n: Float): Vector2f = Vector2f(this).mul(n) +operator fun Vector2f.times(n: Double): Vector2f = Vector2f(this).mul(n.toFloat()) +operator fun Vector2f.times(n: Number): Vector2f = Vector2f(this).mul(n.toFloat()) + +operator fun Vector2f.div(n: Int): Vector2f = Vector2f(this).div(n.toFloat()) +operator fun Vector2f.div(n: Long): Vector2f = Vector2f(this).div(n.toFloat()) +operator fun Vector2f.div(n: Float): Vector2f = Vector2f(this).div(n) +operator fun Vector2f.div(n: Double): Vector2f = Vector2f(this).div(n.toFloat()) +operator fun Vector2f.div(n: Number): Vector2f = Vector2f(this).div(n.toFloat()) + +operator fun Vector2f.compareTo(n: Int) = length().compareTo(n) +operator fun Vector2f.compareTo(n: Long) = length().compareTo(n) +operator fun Vector2f.compareTo(n: Float) = length().compareTo(n) +operator fun Vector2f.compareTo(n: Double) = length().compareTo(n) +operator fun Vector2f.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector2f.plus(vec: Vector2f): Vector2f = Vector2f(this).add(vec) + +operator fun Vector2f.minus(vec: Vector2f): Vector2f = Vector2f(this).sub(vec) + +operator fun Vector2f.times(vec: Vector2f): Vector2f = Vector2f(this).mul(vec) + +operator fun Vector2f.div(vec: Vector2f): Vector2f = Vector2f(this).div(vec) + +infix fun Vector2f.dot(vec: Vector2f): Float = Vector2f(this).dot(vec) + +operator fun Vector2f.component1() = x +operator fun Vector2f.component2() = y + + +// Vector2d operations + +operator fun Vector2d.unaryMinus(): Vector2d = Vector2d(this).mul(-1.0) + +operator fun Vector2d.not(): Vector2d = Vector2d(this).mul(-1.0) + +operator fun Vector2d.plus(n: Int): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).add(nDouble, nDouble) } +operator fun Vector2d.plus(n: Long): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).add(nDouble, nDouble) } +operator fun Vector2d.plus(n: Float): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).add(nDouble, nDouble) } +operator fun Vector2d.plus(n: Double): Vector2d = Vector2d(this).add(n, n) +operator fun Vector2d.plus(n: Number): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).add(nDouble, nDouble) } + +operator fun Vector2d.minus(n: Int): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).sub(nDouble, nDouble) } +operator fun Vector2d.minus(n: Long): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).sub(nDouble, nDouble) } +operator fun Vector2d.minus(n: Float): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).sub(nDouble, nDouble) } +operator fun Vector2d.minus(n: Double): Vector2d = Vector2d(this).sub(n, n) +operator fun Vector2d.minus(n: Number): Vector2d = n.toDouble().let { nDouble -> Vector2d(this).sub(nDouble, nDouble) } + +operator fun Vector2d.times(n: Int): Vector2d = Vector2d(this).mul(n.toDouble()) +operator fun Vector2d.times(n: Long): Vector2d = Vector2d(this).mul(n.toDouble()) +operator fun Vector2d.times(n: Float): Vector2d = Vector2d(this).mul(n.toDouble()) +operator fun Vector2d.times(n: Double): Vector2d = Vector2d(this).mul(n) +operator fun Vector2d.times(n: Number): Vector2d = Vector2d(this).mul(n.toDouble()) + +operator fun Vector2d.div(n: Int): Vector2d = Vector2d(this).div(n.toDouble()) +operator fun Vector2d.div(n: Long): Vector2d = Vector2d(this).div(n.toDouble()) +operator fun Vector2d.div(n: Float): Vector2d = Vector2d(this).div(n.toDouble()) +operator fun Vector2d.div(n: Double): Vector2d = Vector2d(this).div(n) +operator fun Vector2d.div(n: Number): Vector2d = Vector2d(this).div(n.toDouble()) + +operator fun Vector2d.compareTo(n: Int) = length().compareTo(n) +operator fun Vector2d.compareTo(n: Long) = length().compareTo(n) +operator fun Vector2d.compareTo(n: Float) = length().compareTo(n) +operator fun Vector2d.compareTo(n: Double) = length().compareTo(n) +operator fun Vector2d.compareTo(n: Number) = length().compareTo(n.toDouble()) + +operator fun Vector2d.plus(vec: Vector2d): Vector2d = Vector2d(this).add(vec) + +operator fun Vector2d.minus(vec: Vector2d): Vector2d = Vector2d(this).sub(vec) + +operator fun Vector2d.times(vec: Vector2d): Vector2d = Vector2d(this).mul(vec) + +operator fun Vector2d.div(vec: Vector2d): Vector2d = Vector2d(this).div(vec) + +infix fun Vector2d.dot(vec: Vector2d): Double = Vector2d(this).dot(vec) + +operator fun Vector2d.component1() = x +operator fun Vector2d.component2() = y diff --git a/silk-core/src/main/kotlin/net/silkmc/silk/core/world/pos/BasicPositions.kt b/silk-core/src/main/kotlin/net/silkmc/silk/core/world/pos/BasicPositions.kt index 5b468a8d..23ced76b 100644 --- a/silk-core/src/main/kotlin/net/silkmc/silk/core/world/pos/BasicPositions.kt +++ b/silk-core/src/main/kotlin/net/silkmc/silk/core/world/pos/BasicPositions.kt @@ -8,8 +8,60 @@ import net.minecraft.core.BlockPos import net.minecraft.core.Vec3i import net.minecraft.world.phys.Vec2 import net.minecraft.world.phys.Vec3 +import org.joml.Vector2d +import org.joml.Vector2f +import org.joml.Vector2i import org.joml.Vector3d import org.joml.Vector3f +import org.joml.Vector3i + +fun pos3iOf(x: Int, y: Int, z: Int) = Pos3i(x, y, z) +fun pos3fOf(x: Float, y: Float, z: Float) = Pos3f(x, y, z) +fun pos3dOf(x: Double, y: Double, z: Double) = Pos3d(x, y, z) + +fun pos2iOf(x: Int, y: Int) = Pos2i(x, y) +fun pos2fOf(x: Float, y: Float) = Pos2f(x, y) +fun pos2dOf(x: Double, y: Double) = Pos2d(x, y) + +fun BlockPos.toPos3i(): Pos3i = Pos3i(x, y, z) +fun BlockPos.toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) +fun BlockPos.toPos3d(): Pos3d = Pos3d(x.toDouble(), y.toDouble(), z.toDouble()) + +fun Vec3i.toPos3i(): Pos3i = Pos3i(x, y, z) +fun Vec3i.toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) +fun Vec3i.toPos3d(): Pos3d = Pos3d(x.toDouble(), y.toDouble(), z.toDouble()) + +fun Vec3.toPos3i(): Pos3i = Pos3i(x.toInt(), y.toInt(), z.toInt()) +fun Vec3.toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) +fun Vec3.toPos3d(): Pos3d = Pos3d(x, y, z) + +fun Vector3i.toPos3i(): Pos3i = Pos3i(x, y, z) +fun Vector3i.toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) +fun Vector3i.toPos3d(): Pos3d = Pos3d(x.toDouble(), y.toDouble(), z.toDouble()) + +fun Vector3f.toPos3i(): Pos3i = Pos3i(x.toInt(), y.toInt(), z.toInt()) +fun Vector3f.toPos3f(): Pos3f = Pos3f(x, y, z) +fun Vector3f.toPos3d(): Pos3d = Pos3d(x.toDouble(), y.toDouble(), z.toDouble()) + +fun Vector3d.toPos3i(): Pos3i = Pos3i(x.toInt(), y.toInt(), z.toInt()) +fun Vector3d.toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) +fun Vector3d.toPos3d(): Pos3d = Pos3d(x, y, z) + +fun Vec2.toPos2i(): Pos2i = Pos2i(x.toInt(), y.toInt()) +fun Vec2.toPos2f(): Pos2f = Pos2f(x, y) +fun Vec2.toPos2d(): Pos2d = Pos2d(x.toDouble(), y.toDouble()) + +fun Vector2i.toPos2i(): Pos2i = Pos2i(x, y) +fun Vector2i.toPos2f(): Pos2f = Pos2f(x.toFloat(), y.toFloat()) +fun Vector2i.toPos2d(): Pos2d = Pos2d(x.toDouble(), y.toDouble()) + +fun Vector2f.toPos2i(): Pos2i = Pos2i(x.toInt(), y.toInt()) +fun Vector2f.toPos2f(): Pos2f = Pos2f(x, y) +fun Vector2f.toPos2d(): Pos2d = Pos2d(x.toDouble(), y.toDouble()) + +fun Vector2d.toPos2i(): Pos2i = Pos2i(x.toInt(), y.toInt()) +fun Vector2d.toPos2f(): Pos2f = Pos2f(x.toFloat(), y.toFloat()) +fun Vector2d.toPos2d(): Pos2d = Pos2d(x, y) /** * Base interface for position class implementations. @@ -28,6 +80,10 @@ sealed interface IPos { */ val z: N + fun toPos2i(): Pos2i = Pos2i(x.toInt(), z.toInt()) + fun toPos2f(): Pos2f = Pos2f(x.toFloat(), z.toFloat()) + fun toPos2d(): Pos2d = Pos2d(x.toDouble(), z.toDouble()) + /** * Converts this position to a basic Kotlin [Pair] of [x] and [z]. */ @@ -60,6 +116,10 @@ sealed interface Pos3Dimensional : IPos { */ val y: N + fun toPos3i(): Pos3i = Pos3i(x.toInt(), y.toInt(), z.toInt()) + fun toPos3f(): Pos3f = Pos3f(x.toFloat(), y.toFloat(), z.toFloat()) + fun toPos3d(): Pos3d = Pos3d(x.toDouble(), y.toDouble(), z.toDouble()) + /** * Converts this position to a Kotlin [Triple] of [x], [y] and [z]. */ diff --git a/silk-core/src/main/resources/silk-core.mixins.json b/silk-core/src/main/resources/silk-core.mixins.json index ec54db7e..ca52953a 100644 --- a/silk-core/src/main/resources/silk-core.mixins.json +++ b/silk-core/src/main/resources/silk-core.mixins.json @@ -1,15 +1,15 @@ { - "package": "net.silkmc.silk.core.mixin", - "required": true, - "compatibilityLevel": "JAVA_21", - "mixins": [ - "block.AbstractBlockAccessor", - "entity.MixinEntity", - "entity.MixinLivingEntity", - "server.MixinMinecraftServer", - "server.MixinPlayerList", - "server.MixinServerConfigurationPacketListenerImpl", - "server.MixinServerGamePacketListenerImpl", - "server.MixinServerLoginPacketListenerImpl" - ] + "package": "net.silkmc.silk.core.mixin", + "required": true, + "compatibilityLevel": "JAVA_21", + "mixins": [ + "block.AbstractBlockAccessor", + "entity.MixinEntity", + "entity.MixinLivingEntity", + "server.MixinMinecraftServer", + "server.MixinPlayerList", + "server.MixinServerConfigurationPacketListenerImpl", + "server.MixinServerGamePacketListenerImpl", + "server.MixinServerLoginPacketListenerImpl" + ] }