修改贝塞尔曲线的实现， 使得参数更符合网页生成

Author: CooStack

common/src/main/kotlin/cn/coostack/cooparticlesapi/annotations/codec/CodecHelper.kt

@@ -124,7 +124,7 @@ object CodecHelper {
         )
         register(
             BlockPos::class.java,
-            StreamCodec.of({ a, b -> BlockPos.STREAM_CODEC.encode(a, b) }, { BlockPos.STREAM_CODEC.decode(it) })
+            StreamCodec.of(BlockPos.STREAM_CODEC::encode, BlockPos.STREAM_CODEC::decode)
         )
         register(
             BlockState::class.java,

common/src/main/kotlin/cn/coostack/cooparticlesapi/utils/Math3DUtil.kt

@@ -1217,6 +1217,33 @@ object Math3DUtil {
         }
     }
 
+    fun evaluateBezierCurveYAtX(
+        target: RelativeLocation,
+        startHandle: RelativeLocation,
+        endHandle: RelativeLocation,
+        x: Double,
+        iterations: Int = 26
+    ): Double {
+        if (target.x <= 0.0) return target.y
+        val actualX = x.coerceIn(0.0, target.x)
+        if (actualX <= 0.0) return 0.0
+        if (actualX >= target.x) return target.y
+        val end = target + endHandle
+        var lo = 0.0
+        var hi = 1.0
+        var mid = 0.5
+        repeat(iterations.coerceAtLeast(1)) {
+            mid = (lo + hi) * 0.5
+            val bx = cubicBezier(mid, 0.0, startHandle.x, end.x, target.x)
+            if (bx < actualX) {
+                lo = mid
+            } else {
+                hi = mid
+            }
+        }
+        return cubicBezier(mid, 0.0, startHandle.y, end.y, target.y)
+    }
+
     fun cubicBezier(t: Double, p0: Double, p1: Double, p2: Double, p3: Double): Double {
         val u = 1 - t
         val u2 = u * u

common/src/main/kotlin/cn/coostack/cooparticlesapi/utils/helper/BezierValueScaleHelper.kt

@@ -14,28 +14,47 @@ abstract class BezierValueScaleHelper(
     var controlPoint2: RelativeLocation
 ) :
     ScaleHelper(minScale, maxScale, scaleTick) {
-    private val deltaScale = maxScale - minScale
+    private val deltaScale: Double
+        get() = maxScale - minScale
 
-    var bezierPoints = Math3DUtil.generateBezierCurve(
-        RelativeLocation(scaleTick.toDouble(), deltaScale, 0.0),
-        controlPoint1, controlPoint2, scaleTick
-    )
+    var bezierPoints = createBezierPoints()
+
+    private fun createBezierPoints(): List<RelativeLocation> {
+        val target = RelativeLocation(scaleTick.toDouble(), deltaScale, 0.0)
+        val (startHandle, endHandle) = resolveControlPoints()
+        return List(scaleTick + 1) { tick ->
+            RelativeLocation(
+                tick.toDouble(),
+                Math3DUtil.evaluateBezierCurveYAtX(
+                    target,
+                    startHandle,
+                    endHandle,
+                    tick.toDouble()
+                ),
+                0.0
+            )
+        }
+    }
+
+    private fun resolveControlPoints(): Pair<RelativeLocation, RelativeLocation> {
+        if (controlPoint2.x > 0.0 && controlPoint2.x <= scaleTick.toDouble()) {
+            return RelativeLocation(controlPoint1.x, controlPoint1.y - minScale, controlPoint1.z) to
+                RelativeLocation(controlPoint2.x - scaleTick, controlPoint2.y - maxScale, controlPoint2.z)
+        }
+        return controlPoint1.clone() to controlPoint2.clone()
+    }
 
     override fun recalculateStep(): BezierValueScaleHelper {
         val temp = min(minScale, maxScale)
         maxScale = max(minScale, maxScale)
         minScale = temp
-        bezierPoints = Math3DUtil.generateBezierCurve(
-            RelativeLocation(scaleTick.toDouble(), deltaScale, 0.0),
-            controlPoint1, controlPoint2, scaleTick
-        )
+        bezierPoints = createBezierPoints()
         return this
     }
 
     override fun toggleScale(scale: Double) {
-        // 遍历scale?
         val currentPoint = bezierPoints.withIndex().minBy {
-            abs(it.value.y - scale)
+            abs(minScale + it.value.y - scale)
         }
         current = currentPoint.index
         scale(minScale + currentPoint.value.y)
@@ -44,23 +63,18 @@ abstract class BezierValueScaleHelper(
     override fun doScale() {
         if (getLoadedGroup() == null) return
         if (over()) return
-        val value = bezierPoints[current++].y
-        scale(minScale + value)
+        current = (current + 1).coerceAtMost(scaleTick)
+        scale(minScale + bezierPoints[current].y)
     }
 
     override fun doScaleTo(current: Int) {
-        val enter = current.coerceAtLeast(0)
+        val enter = current.coerceIn(0, scaleTick)
         this.current = enter
-        if (current >= scaleTick) {
-            resetScaleMax()
-            return
-        }
-        if (current <= 0) {
-            resetScaleMin()
-            return
+        when {
+            enter <= 0 -> scale(minScale)
+            enter >= scaleTick -> scale(maxScale)
+            else -> scale(minScale + bezierPoints[enter].y)
         }
-        val value = bezierPoints[current].y
-        scale(minScale + value)
     }
 
     override fun doScaleReversed() {
@@ -70,7 +84,7 @@ abstract class BezierValueScaleHelper(
         if (isZero()) {
             return
         }
-        val value = bezierPoints[max(0, --current)].y
-        scale(minScale + value)
+        current = max(0, current - 1)
+        scale(minScale + bezierPoints[current].y)
     }
 }