hoveredState: Rewrite to be much more efficient

Instead of doing a hitTest for each hoverable component, we now do a
single one per Window and distribut the result.

This also removes the `hitTest` argument because it is now an inherent
part of how it functions and we never disabled it anyway (and there
isn't really any reason you'd ever want to).

This also removes the `layoutSafe` argument because the the new
`UpdateFunc` API this uses is layout safe by default, with no extra
frame delay necessary.

Source-Commit: 7e67d6c184370ac5633b44c74a893daba2031d32

Author: Johni0702

unstable/layoutdsl/src/main/kotlin/gg/essential/elementa/layoutdsl/layout.kt

@@ -12,7 +12,6 @@ import gg.essential.elementa.state.v2.collections.TrackedList
 import gg.essential.elementa.state.v2.collections.trackedListOf
 import gg.essential.elementa.state.v2.combinators.map
 import gg.essential.elementa.state.v2.combinators.not
-import gg.essential.elementa.util.hoveredState
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -49,9 +48,6 @@ class LayoutScope(
 
     operator fun LayoutDslComponent.invoke(modifier: Modifier = Modifier) = layout(modifier)
 
-    @Deprecated("Use Modifier.hoverScope() and Modifier.whenHovered(), instead.")
-    fun hoveredState(hitTest: Boolean = true, layoutSafe: Boolean = true) = component.hoveredState(hitTest, layoutSafe)
-
     @Suppress("FunctionName")
     fun if_(state: State<Boolean>, cache: Boolean = true, block: LayoutScope.() -> Unit): IfDsl {
         return if_(state.toV2(), cache, block)

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

@@ -20,6 +20,11 @@ import gg.essential.elementa.state.v2.State as StateV2
 val UIComponent.hasWindow: Boolean
     get() = this is Window || hasParent && parent.hasWindow
 
+inline fun <reified T : Effect> UIComponent.get() =
+    effects.firstNotNullOfOrNull { it as? T }
+inline fun <reified T : Effect> UIComponent.getOrPut(init: () -> T) =
+    get<T>() ?: init().also { enableEffect(it) }
+
 fun <T> UIComponent.pollingState(initialValue: T? = null, getter: () -> T): State<T> {
     val state = BasicState(initialValue ?: getter())
     enableEffect(object : Effect() {
@@ -122,98 +127,50 @@ fun UIComponent.onAnimationFrame(block: () -> Unit) =
 
 /**
  * Returns a state representing whether this UIComponent is hovered
- *
- * [hitTest] will perform a hit test to make sure the user is actually hovered over this component
- * as compared to the mouse just being within its content bounds while being hovered over another
- * component rendered above this.
- *
- * [layoutSafe] will delay the state change until a time in which it is safe to make layout changes.
- * This option will induce an additional delay of one frame because the state is updated during the next
- * [Window.enqueueRenderOperation] after the hoverState changes.
  */
-fun UIComponent.hoveredStateV2(hitTest: Boolean = true, layoutSafe: Boolean = true): StateV2<Boolean> {
-    // "Unsafe" means that it is not safe to depend on this for layout changes
-    val unsafeHovered = mutableStateOf(false)
+fun UIComponent.hoveredStateV2(): StateV2<Boolean> {
+    return getOrPut { ComponentHoveredState() }.state
+}
+
+private class WindowHoveredState : Effect() {
+    private var oldHovered = listOf<UIComponent>()
 
-    // "Safe" because layout changes can directly happen when this changes (ie in onSetValue)
-    val safeHovered = mutableStateOf(false)
+    init { addUpdateFunc { _, _ -> update() } }
+    private fun update() {
+        val window = boundComponent as Window
 
-    // Performs a hit test based on the current mouse x / y
-    fun hitTestHovered(): Boolean {
         // Positions the mouse in the center of pixels so isPointInside will
         // pass for items 1 pixel wide objects. See ElementaVersion v2 for more details
         val halfPixel = 0.5f / UResolution.scaleFactor.toFloat()
         val mouseX = UMouse.Scaled.x.toFloat() + halfPixel
         val mouseY = UMouse.Scaled.y.toFloat() + halfPixel
-        return if (isPointInside(mouseX, mouseY)) {
 
-            val window = Window.of(this)
-            val hit = (window.hoveredFloatingComponent?.hitTest(mouseX, mouseY)) ?: window.hitTest(mouseX, mouseY)
-
-            hit.isComponentInParentChain(this) || hit == this
-        } else {
-            false
-        }
-    }
-
-    if (hitTest) {
-        // It's possible the animation framerate will exceed that of the actual frame rate
-        // Therefore, in order to avoid redundantly performing the hit test multiple times
-        // in the same frame, this boolean is used to ensure that hit testing is performed
-        // at most only a single time each frame
-        var registerHitTest = true
-
-        onAnimationFrame {
-            if (registerHitTest) {
-                registerHitTest = false
-                Window.enqueueRenderOperation {
-                    // The next animation frame should register another renderOperation
-                    registerHitTest = true
-
-                    // It is possible that this component or a component in its parent tree
-                    // was removed from the component tree between the last call to animationFrame
-                    // and this evaluation in enqueueRenderOperation. If that is the case, we should not
-                    // perform the hit test because it will throw an exception.
-                    if (!this.isInComponentTree()) {
-                        // Unset the hovered state because a component can no longer
-                        // be hovered if it is not in the component tree
-                        unsafeHovered.set(false)
-                        return@enqueueRenderOperation
-                    }
-
-                    // Since enqueueRenderOperation will keep polling the queue until there are no more items,
-                    // the forwarding of any update to the safeHovered state will still happen this frame
-                    unsafeHovered.set(hitTestHovered())
-                }
+        val hit = (window.hoveredFloatingComponent?.hitTest(mouseX, mouseY)) ?: window.hitTest(mouseX, mouseY)
+        val newHovered = hit.selfAndParents().toList()
+        for (component in oldHovered) {
+            if (component !in newHovered) {
+                component.get<ComponentHoveredState>()?.state?.set(false)
             }
         }
-    }
-    onMouseEnter {
-        if (hitTest) {
-            unsafeHovered.set(hitTestHovered())
-        } else {
-            unsafeHovered.set(true)
+        for (component in newHovered) {
+            if (component !in oldHovered) {
+                component.get<ComponentHoveredState>()?.state?.set(true)
+            }
         }
+        oldHovered = newHovered
     }
+}
 
-    onMouseLeave {
-        unsafeHovered.set(false)
-    }
+private class ComponentHoveredState : Effect() {
+    val state = mutableStateOf(false)
 
-    return if (layoutSafe) {
-        unsafeHovered.onChange(this) { hovered ->
-            Window.enqueueRenderOperation {
-                safeHovered.set(hovered)
-            }
-        }
-        safeHovered
-    } else {
-        unsafeHovered
+    override fun setup() {
+        Window.of(boundComponent).getOrPut { WindowHoveredState() }
     }
 }
 
-fun UIComponent.hoveredState(hitTest: Boolean = true, layoutSafe: Boolean = true): State<Boolean> =
-    hoveredStateV2(hitTest, layoutSafe).toV1(this)
+fun UIComponent.hoveredState(): State<Boolean> =
+    hoveredStateV2().toV1(this)
 
 /** Marker effect for [makeHoverScope]/[hoverScope]. */
 private class HoverScope(val state: StateV2<Boolean>) : Effect()