- coherenced all byteArray and byteBuffer constructors

- hashCode()

Author: elect86

src/main/kotlin/glm_/extensions.kt

@@ -57,8 +57,8 @@ infix fun Int.xor(b: Char) = this xor b.i
 
 val Int.uc get() = (this % 256).c // TODO others
 
-fun ByteArray.getFloat(index: Int, bigEndianess: Boolean = true) = Float.intBitsToFloat(
-        if (bigEndianess) this[index].i and 0xFF or
+fun ByteArray.getFloat(index: Int, bigEndian: Boolean = true) = Float.intBitsToFloat(
+        if (bigEndian) this[index].i and 0xFF or
                 (this[index + 1].i and 0xFF shl 8) or
                 (this[index + 2].i and 0xFF shl 16) or
                 (this[index + 3].i and 0xFF shl 24)
@@ -68,8 +68,8 @@ fun ByteArray.getFloat(index: Int, bigEndianess: Boolean = true) = Float.intBits
                 (this[index].i and 0xFF shl 24)
 )
 
-fun ByteArray.getDouble(index: Int, bigEndianess: Boolean = true) = Double.longBitsToDouble(
-        if (bigEndianess) this[index].L and 0xFF or
+fun ByteArray.getDouble(index: Int, bigEndian: Boolean = true) = Double.longBitsToDouble(
+        if (bigEndian) this[index].L and 0xFF or
                 (this[index + 1].L and 0xFF shl 8) or
                 (this[index + 2].L and 0xFF shl 16) or
                 (this[index + 3].L and 0xFF shl 24) or
@@ -86,8 +86,8 @@ fun ByteArray.getDouble(index: Int, bigEndianess: Boolean = true) = Double.longB
                 (this[index + 1].L and 0xFF shl 48) or
                 (this[index].L and 0xFF shl 56))
 
-fun ByteArray.getInt(index: Int, bigEndianess: Boolean = true) =
-        if (bigEndianess) this[index].i and 0xFF or
+fun ByteArray.getInt(index: Int, bigEndian: Boolean = true) =
+        if (bigEndian) this[index].i and 0xFF or
                 (this[index + 1].i and 0xFF shl 8) or
                 (this[index + 2].i and 0xFF shl 16) or
                 (this[index + 3].i and 0xFF shl 24)
@@ -96,8 +96,8 @@ fun ByteArray.getInt(index: Int, bigEndianess: Boolean = true) =
                 (this[index + 1].i and 0xFF shl 16) or
                 (this[index].i and 0xFF shl 24)
 
-fun ByteArray.getLong(index: Int, bigEndianess: Boolean = true) =
-        if (bigEndianess) this[index].L and 0xFF or
+fun ByteArray.getLong(index: Int, bigEndian: Boolean = true) =
+        if (bigEndian) this[index].L and 0xFF or
                 (this[index + 1].L and 0xFF shl 8) or
                 (this[index + 2].L and 0xFF shl 16) or
                 (this[index + 3].L and 0xFF shl 24) or
@@ -114,17 +114,17 @@ fun ByteArray.getLong(index: Int, bigEndianess: Boolean = true) =
                 (this[index + 1].L and 0xFF shl 48) or
                 (this[index].L and 0xFF shl 56)
 
-fun ByteArray.getShort(index: Int, bigEndianess: Boolean = true) =
-        if (bigEndianess)
+fun ByteArray.getShort(index: Int, bigEndian: Boolean = true) =
+        if (bigEndian)
             this[index].s and 0xFF or (this[index + 1].s and 0xFF shl 8)
         else
             this[index + 1].s and 0xFF or (this[index].s and 0xFF shl 56)
 
 // skipping getUbyte, since it'main.getS a simply .main.getUb
-fun ByteArray.getUint(index: Int, bigEndianess: Boolean = true) = getInt(index, bigEndianess).ui
+fun ByteArray.getUint(index: Int, bigEndian: Boolean = true) = getInt(index, bigEndian).ui
 
-fun ByteArray.getUlong(index: Int, bigEndianess: Boolean = true) = getLong(index, bigEndianess).ul
-fun ByteArray.getUshort(index: Int, bigEndianess: Boolean = true) = getShort(index, bigEndianess).us
+fun ByteArray.getUlong(index: Int, bigEndian: Boolean = true) = getLong(index, bigEndian).ul
+fun ByteArray.getUshort(index: Int, bigEndian: Boolean = true) = getShort(index, bigEndian).us
 
 
 infix fun Byte.shl(other: Byte) = (i shl other.i).b
@@ -170,42 +170,42 @@ val String.us get() = Ushort(this)
 val String.bi get() = if (startsWith("0x")) BigInteger(substring(2), 16) else BigInteger(this)
 
 
-fun InputStream.int(bigEndianess: Boolean = true): Int {
+fun InputStream.int(bigEndian: Boolean = true): Int {
     val a = read()
     val b = read()
     val c = read()
     val d = read()
-    if (bigEndianess)
+    if (bigEndian)
         return (a shl 24) + (b shl 16) + (c shl 8) + d
     else
         return (d shl 24) + (c shl 16) + (b shl 8) + a
 }
 
-fun InputStream.short(bigEndianess: Boolean = true): Int {
+fun InputStream.short(bigEndian: Boolean = true): Int {
     val a = read()
     val b = read()
-    if (bigEndianess)
+    if (bigEndian)
         return (a shl 8) + b
     else
         return (b shl 8) + a
 }
 
 fun InputStream.byte() = read().b
 
-fun InputStream.float(bigEndianess: Boolean = true) = Float.intBitsToFloat(int(bigEndianess))
-fun InputStream.double(bigEndianess: Boolean = true) = Double.longBitsToDouble(long(bigEndianess))
+fun InputStream.float(bigEndian: Boolean = true) = Float.intBitsToFloat(int(bigEndian))
+fun InputStream.double(bigEndian: Boolean = true) = Double.longBitsToDouble(long(bigEndian))
 
-fun InputStream.long(bigEndianess: Boolean = true): Long {
-    val a = int(bigEndianess)
-    val b = int(bigEndianess)
+fun InputStream.long(bigEndian: Boolean = true): Long {
+    val a = int(bigEndian)
+    val b = int(bigEndian)
     return (b.L shl 32) + a
 }
 
-fun InputStream.mat4(bigEndianess: Boolean = true) = Mat4(
-        float(bigEndianess), float(bigEndianess), float(bigEndianess), float(bigEndianess),
-        float(bigEndianess), float(bigEndianess), float(bigEndianess), float(bigEndianess),
-        float(bigEndianess), float(bigEndianess), float(bigEndianess), float(bigEndianess),
-        float(bigEndianess), float(bigEndianess), float(bigEndianess), float(bigEndianess))
+fun InputStream.mat4(bigEndian: Boolean = true) = Mat4(
+        float(bigEndian), float(bigEndian), float(bigEndian), float(bigEndian),
+        float(bigEndian), float(bigEndian), float(bigEndian), float(bigEndian),
+        float(bigEndian), float(bigEndian), float(bigEndian), float(bigEndian),
+        float(bigEndian), float(bigEndian), float(bigEndian), float(bigEndian))
 
 val Any.toFloat: Float
     get() = when (this) {

src/main/kotlin/glm_/mat2x2/Mat2.kt

@@ -218,4 +218,5 @@ data class Mat2(override var value: MutableList<Vec2>) : Mat2x2t<Vec2>(value) {
     override fun equals(other: Any?) = other is Mat2 &&
             this[0, 0] == other[0, 0] && this[0, 1] == other[0, 1] &&
             this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1]
+    override fun hashCode() = 31 * value[0].hashCode() + value[1].hashCode()
 }

src/main/kotlin/glm_/mat2x2/Mat2d.kt

@@ -219,4 +219,5 @@ data class Mat2d(override var value: MutableList<Vec2d>) : Mat2x2t<Vec2d>(value)
     override fun equals(other: Any?) = other is Mat2 &&
             this[0, 0] == other[0, 0] && this[0, 1] == other[0, 1] &&
             this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1]
+    override fun hashCode() = 31 * value[0].hashCode() + value[1].hashCode()
 }

src/main/kotlin/glm_/mat3x3/Mat3.kt

@@ -379,4 +379,5 @@ data class Mat3(override var value: MutableList<Vec3>) : Mat3x3t<Vec3>(value) {
             this[0, 0] == other[0, 0] && this[0, 1] == other[0, 1] && this[0, 2] == other[0, 2] &&
             this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1] && this[1, 2] == other[1, 2] &&
             this[2, 0] == other[2, 0] && this[2, 1] == other[2, 1] && this[2, 2] == other[2, 2]
+    override fun hashCode() = 31 * (31 * value[0].hashCode() + value[1].hashCode()) + value[2].hashCode()
 }

src/main/kotlin/glm_/mat3x3/Mat3d.kt

@@ -363,4 +363,5 @@ data class Mat3d(override var value: MutableList<Vec3d>) : Mat3x3t<Vec3d>(value)
             this[0, 0] == other[0, 0] && this[0, 1] == other[0, 1] && this[0, 2] == other[0, 2] &&
             this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1] && this[1, 2] == other[1, 2] &&
             this[2, 0] == other[2, 0] && this[2, 1] == other[2, 1] && this[2, 2] == other[2, 2]
+    override fun hashCode() = 31 * (31 * value[0].hashCode() + value[1].hashCode()) + value[2].hashCode()
 }

src/main/kotlin/glm_/mat4x4/Mat4.kt

@@ -137,11 +137,11 @@ data class Mat4(override var value: MutableList<Vec4>) : Mat4x4t<Vec4>(value) {
                     Vec4(floats, 12)))
 
     // TODO others
-    constructor(inputStream: InputStream, bigEndianess: Boolean = true) : this(
-            inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess),
-            inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess),
-            inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess),
-            inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess))
+    constructor(inputStream: InputStream, bigEndian: Boolean = true) : this(
+            inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian),
+            inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian),
+            inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian),
+            inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian))
 
     fun put(v0: Vec4, v1: Vec4, v2: Vec4, v3: Vec4) {
         value[0] to v0
@@ -546,5 +546,5 @@ data class Mat4(override var value: MutableList<Vec4>) : Mat4x4t<Vec4>(value) {
             this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1] && this[1, 2] == other[1, 2] && this[1, 3] == other[1, 3] &&
             this[2, 0] == other[2, 0] && this[2, 1] == other[2, 1] && this[2, 2] == other[2, 2] && this[2, 3] == other[2, 3] &&
             this[3, 0] == other[3, 0] && this[3, 1] == other[3, 1] && this[3, 2] == other[3, 2] && this[3, 3] == other[3, 3]
-}
-
+    override fun hashCode() = 31 * (31 * (31 * value[0].hashCode() + value[1].hashCode()) + value[2].hashCode()) + value[3].hashCode()
+}

src/main/kotlin/glm_/mat4x4/Mat4d.kt

@@ -522,7 +522,11 @@ data class Mat4d(override var value: MutableList<Vec4d>) : Mat4x4t<Vec4d>(value)
             this[0][2] == 0.0 && this[1][2] == 0.0 && this[2][2] == 1.0 && this[3][2] == 0.0 &&
             this[0][3] == 0.0 && this[1][3] == 0.0 && this[2][3] == 0.0 && this[3][3] == 1.0
 
-
+    override fun equals(other: Any?) = other is Mat4d &&
+            this[0, 0] == other[0, 0] && this[0, 1] == other[0, 1] && this[0, 2] == other[0, 2] && this[0, 3] == other[0, 3] &&
+            this[1, 0] == other[1, 0] && this[1, 1] == other[1, 1] && this[1, 2] == other[1, 2] && this[1, 3] == other[1, 3] &&
+            this[2, 0] == other[2, 0] && this[2, 1] == other[2, 1] && this[2, 2] == other[2, 2] && this[2, 3] == other[2, 3] &&
+            this[3, 0] == other[3, 0] && this[3, 1] == other[3, 1] && this[3, 2] == other[3, 2] && this[3, 3] == other[3, 3]
+    override fun hashCode() = 31 * (31 * (31 * value[0].hashCode() + value[1].hashCode()) + value[2].hashCode()) + value[3].hashCode()
     override fun toString() = super.toString()
-}
-
+}

src/main/kotlin/glm_/quat/Quat.kt

@@ -59,8 +59,8 @@ class Quat(w: Float, x: Float, y: Float, z: Float) : QuatT<Float>(w, x, y, z) {
 //        quat_cast(m, this)
 //    }
 
-    constructor(inputStream: InputStream, bigEndianess: Boolean = true) :
-            this(inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess), inputStream.float(bigEndianess))
+    constructor(inputStream: InputStream, bigEndian: Boolean = true) :
+            this(inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian), inputStream.float(bigEndian))
 
     infix fun to(res: Mat3) = glm.mat3_cast(this, res)
     fun toMat3() = glm.mat3_cast(this, Mat3())
@@ -188,6 +188,7 @@ class Quat(w: Float, x: Float, y: Float, z: Float) : QuatT<Float>(w, x, y, z) {
     override fun toString() = "($w | $x, $y, $z)"
 
     override fun equals(other: Any?) = other is Quat && this[0] == other[0] && this[1] == other[1] && this[2] == other[2] && this[3] == other[3]
+    override fun hashCode() = 31 * (31 * (31 * w.hashCode() + x.hashCode()) + y.hashCode()) + z.hashCode()
 
     @JvmOverloads
     fun vectorize(res: Vec4 = Vec4()) = res.put(x, y, z, w)

src/main/kotlin/glm_/quat/QuatD.kt

@@ -181,6 +181,7 @@ class QuatD(w: Double, x: Double, y: Double, z: Double) : QuatT<Double>(w, x, y,
     override fun toString() = "($x, $y, $z), $w"
 
     override fun equals(other: Any?) = other is QuatD && this[0] == other[0] && this[1] == other[1] && this[2] == other[2] && this[3] == other[3]
+    override fun hashCode() = 31 * (31 * (31 * w.hashCode() + x.hashCode()) + y.hashCode()) + z.hashCode()
 
     @JvmOverloads
     fun vectorize(res: Vec4d = Vec4d()) = res.put(x, y, z, w)

src/main/kotlin/glm_/vec1/Vec1.kt

@@ -32,8 +32,8 @@ class Vec1(x: Float) : Vec1t<Float>(x) {
     constructor(v: Vec3bool) : this(v.x.f)
     constructor(v: Vec4bool) : this(v.x.f)
 
-    constructor(bytes: ByteArray, index: Int = 0, oneByteOneFloat: Boolean = true, bigEndianess: Boolean = true)
-            : this(if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index, bigEndianess))
+    constructor(bytes: ByteArray, index: Int = 0, oneByteOneFloat: Boolean = false, bigEndian: Boolean = true)
+            : this(if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index, bigEndian))
 
     constructor(chars: CharArray, index: Int = 0) : this(chars[index].f)
     constructor(shorts: ShortArray, index: Int = 0) : this(shorts[index])
@@ -51,7 +51,7 @@ class Vec1(x: Float) : Vec1t<Float>(x) {
         put(list, index)
     }
 
-    constructor(bytes: ByteBuffer, index: Int = bytes.position(), oneByteOneFloat: Boolean = true)
+    constructor(bytes: ByteBuffer, index: Int = bytes.position(), oneByteOneFloat: Boolean = false)
             : this(if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index))
 
     constructor(chars: CharBuffer, index: Int = chars.position()) : this(chars[index].f)
@@ -64,11 +64,11 @@ class Vec1(x: Float) : Vec1t<Float>(x) {
     constructor(s: Number) : this(s.f)
 
 
-    fun set(bytes: ByteArray, index: Int = 0, oneByteOneFloat: Boolean = true, bigEndianess: Boolean = true) {
-        x = if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index, bigEndianess)
+    fun set(bytes: ByteArray, index: Int = 0, oneByteOneFloat: Boolean = false, bigEndian: Boolean = true) {
+        x = if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index, bigEndian)
     }
 
-    fun set(bytes: ByteBuffer, index: Int = bytes.position(), oneByteOneFloat: Boolean = true) {
+    fun set(bytes: ByteBuffer, index: Int = bytes.position(), oneByteOneFloat: Boolean = false) {
         x = if (oneByteOneFloat) bytes[index].f else bytes.getFloat(index)
     }
 
@@ -124,4 +124,5 @@ class Vec1(x: Float) : Vec1t<Float>(x) {
     }
 
     override fun equals(other: Any?) = other is Vec1 && this[0] == other[0]
+    override fun hashCode() = x.hashCode()
 }