Merge remote-tracking branch 'origin/master'

Author: elect86

src/main/kotlin/glm_/func/func_exponential.kt

@@ -1,5 +1,7 @@
 package glm_.func
 
+import glm_.d
+import glm_.i
 import glm_.vec2.Vec2
 import glm_.vec2.Vec2d
 import glm_.vec3.Vec3
@@ -212,6 +214,7 @@ interface func_exponential {
 
     fun log2(a: Double) = _log2(a)
     fun log2(a: Float) = _log2(a)
+    fun log2(a: Int) = _log2(a.d).i
 
     fun log2(a: Vec2, res: Vec2 = Vec2()) {
         res.x = log2(a.x)

src/main/kotlin/glm_/glm.kt

@@ -58,7 +58,11 @@ object glm :
         packing,
         func_packing,
 
-        random {
+        random,
+
+        optimumPow,
+
+        gradientPaint {
 
     @JvmField
     val detail = Detail

src/main/kotlin/glm_/gradientPaint.kt

@@ -0,0 +1,36 @@
+package glm_
+
+import glm_.vec2.Vec2
+
+interface gradientPaint {
+
+    fun radialGradient(
+            center: Vec2,
+            radius: Float,
+            focal: Vec2,
+            position: Vec2
+    ): Float {
+        val fX = focal.x - center.x
+        val fY = focal.y - center.y
+        val dX = position.x - focal.x
+        val dY = position.y - focal.y
+        val radius2 = glm.pow2(radius)
+        val fX2 = glm.pow2(fX)
+        val fY2 = glm.pow2(fY)
+
+        val numerator = (dX * fX + dY * fY) + glm.sqrt(radius2 * (glm.pow2(dX) + glm.pow2(dY)) - glm.pow2(dX * fY - dY * fX))
+        val denominator = radius2 - (fX2 + fY2)
+        return numerator / denominator
+    }
+
+    fun linearGradient(
+            point0: Vec2,
+            point1: Vec2,
+            position: Vec2
+    ): Float {
+        val distX = point1.x - point0.x
+        val distY = point1.y - point0.y
+        val dot = distX * distX + distY * distY
+        return (distX * (position.x - point0.x) + distY * (position.y - point0.y)) / dot
+    }
+}

src/main/kotlin/glm_/optimumPow.kt

@@ -0,0 +1,10 @@
+package glm_
+
+interface optimumPow {
+
+    fun pow2(x: Float) = x * x
+
+    fun pow3(x: Float) = x * x * x
+
+    fun pow4(x: Float) = (x * x) * (x * x)
+}

src/main/kotlin/glm_/round.kt

@@ -8,6 +8,13 @@ import glm_.vec3.Vec3i
 
 interface round {
 
+    fun floorMultiple(source: Int, multiple: Int) = when {
+        source > 0 -> source - source % multiple
+        else -> {
+            val tmp = source + 1
+            tmp - tmp % multiple - multiple
+        }
+    }
 
     fun ceilMultiple(source: Float, multiple: Float) =
             if (source > 0) source + (multiple - source % multiple)