unstable: Use new UpdateFunc API instead of animationFrame

Source-Commit: d51588082b8cfd15e711acd1e6dad102221ff0a5

Author: Johni0702

unstable/layoutdsl/src/main/kotlin/gg/essential/elementa/util/elementaExtensions.kt

@@ -27,38 +27,19 @@ inline fun <reified T : Effect> UIComponent.getOrPut(init: () -> T) =
 
 fun <T> UIComponent.pollingState(initialValue: T? = null, getter: () -> T): State<T> {
     val state = BasicState(initialValue ?: getter())
-    enableEffect(object : Effect() {
-        override fun animationFrame() {
-            state.set(getter())
-        }
-    })
+    addUpdateFunc { _, _ -> state.set(getter()) }
     return state
 }
 
 fun <T> UIComponent.pollingStateV2(initialValue: T? = null, getter: () -> T): StateV2<T> {
     val state = mutableStateOf(initialValue ?: getter())
-    enableEffect(object : Effect() {
-        override fun animationFrame() {
-            state.set(getter())
-        }
-    })
+    addUpdateFunc { _, _ -> state.set(getter()) }
     return state
 }
 
+@Deprecated("pollingState is now layout-safe by default", ReplaceWith("pollingStateV2(initialValue, getter)"))
 fun <T> UIComponent.layoutSafePollingState(initialValue: T? = null, getter: () -> T): StateV2<T> {
-    val state = mutableStateOf(initialValue ?: getter())
-    enableEffect(object : Effect() {
-        override fun animationFrame() {
-            val window = Window.of(boundComponent)
-            // Start one-shot timer which will trigger immediately once the current `animationFrame` is complete
-            window.startTimer(0) { timerId ->
-                window.stopTimer(timerId)
-
-                state.set(getter())
-            }
-        }
-    })
-    return state
+    return pollingStateV2(initialValue, getter)
 }
 
 /**

unstable/statev2/src/main/kotlin/gg/essential/elementa/state/v2/animate.kt

@@ -1,6 +1,7 @@
 package gg.essential.elementa.state.v2
 
 import gg.essential.elementa.UIComponent
+import gg.essential.elementa.components.UpdateFunc
 import gg.essential.elementa.components.Window
 import gg.essential.elementa.constraints.animation.AnimationStrategy
 import gg.essential.elementa.constraints.animation.Animations
@@ -34,34 +35,36 @@ fun State<State<Float>>.animateTransitions(
 }
 
 private class AnimationDriver(
-    private val driver: State<State<Float>>,
+    driver: State<State<Float>>,
     private val resultStateWeakReference: WeakReference<MutableState<State<Float>>>,
     private val duration: Float,
     private val animationStrategy: AnimationStrategy
-): Effect() {
+): Effect(), UpdateFunc {
     private val animationEventList = mutableListOf<AnimationEvent>()
-    private lateinit var driverEffect: () -> Unit
-    private var durationFrames = 1
+    private val driverEffect: () -> Unit
 
     private var previousDriverStateValue = stateOf(0f)
     private var isDestroying = false
 
-    override fun setup() {
+    init {
         previousDriverStateValue = driver.getUntracked()
-        durationFrames = (Window.of(boundComponent).animationFPS * duration).toInt().coerceAtLeast(1)
         driverEffect = driver.onChange(ReferenceHolder.Weak) { input ->
-            animationEventList.add(AnimationEvent(previousDriverStateValue, input, durationFrames))
+            if (animationEventList.isEmpty()) {
+                addUpdateFunc(this@AnimationDriver)
+            }
+            animationEventList.add(AnimationEvent(previousDriverStateValue, input))
             previousDriverStateValue = input
         }
     }
 
-    override fun animationFrame() {
+    override fun invoke(dt: Float, dtMs: Int) {
         val resultState = resultStateWeakReference.get()
         if (resultState == null) {
             destroy()
         } else {
-            animationEventList.forEach { it.age++ }
-            animationEventList.removeIf { it.age >= durationFrames }
+            animationEventList.forEach { it.age += dt }
+            animationEventList.removeIf { it.age >= duration }
+            if (animationEventList.isEmpty()) removeUpdateFunc(this@AnimationDriver)
             resultState.set(State { getAnimationValue() })
         }
     }
@@ -83,7 +86,7 @@ private class AnimationDriver(
         }
 
         return animationEventList.fold(animationEventList.first().startValue()) { acc, event ->
-            val linearProgress = event.age.toFloat() / event.duration.toFloat()
+            val linearProgress = event.age / duration
             val animatedProgress = animationStrategy.getValue(linearProgress)
             acc + ((event.endValue() - acc) * animatedProgress)
         }
@@ -92,8 +95,7 @@ private class AnimationDriver(
     private data class AnimationEvent(
         val startValue: State<Float>,
         val endValue: State<Float>,
-        val duration: Int,
-        var age: Int = 0,
+        var age: Float = 0f,
     )
 
 }