Setting animations rework

Author: bladekt

common/src/main/kotlin/com/lambda/gui/api/component/ListWindow.kt

@@ -3,17 +3,16 @@ package com.lambda.gui.api.component
 import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.component.button.ListButton
 import com.lambda.gui.impl.clickgui.AbstractClickGui
-import com.lambda.module.modules.client.ClickGui
 
 abstract class ListWindow <T : ListButton> (
     owner: AbstractClickGui
 ) : WindowComponent<T>(owner) {
     override fun onEvent(e: GuiEvent) {
-        if (e is GuiEvent.Show || e is GuiEvent.Tick) {
+        if (e is GuiEvent.Tick) {
             var y = 0.0
             contentComponents.children.forEach { button ->
                 button.heightOffset = y
-                y += button.size.y + ClickGui.buttonStep
+                y += button.size.y + button.listStep
             }
         }
 

common/src/main/kotlin/com/lambda/gui/api/component/WindowComponent.kt

@@ -40,7 +40,7 @@ abstract class WindowComponent <T : ChildComponent> (
     private val contentRect get() = rect.shrink(padding).moveFirst(Vec2d(0.0, titleBarHeight - padding))
 
     private val titleBar get() = Rect.basedOn(rect.leftTop, rect.size.x, titleBarHeight)
-    private val titleBarHeight get() = titleFont.height + 2 + padding * 2
+    private val titleBarHeight get() = ClickGui.buttonHeight + padding * 2
     private val titleFont: IFontEntry
 
     private val layer = RenderLayer()
@@ -50,13 +50,12 @@ abstract class WindowComponent <T : ChildComponent> (
     private val animation = owner.animation
     private val gui = owner
 
-    // Show animation for children
-    private val showAnimation0 by animation.exp(0.0, 1.0, 0.5, ::isOpen)
-    override val showAnimation get() = lerp(0.0, showAnimation0, gui.showAnimation)
+    private val showAnimation by animation.exp(0.0, 1.0, 0.6, ::isOpen)
+    override val childShowAnimation get() = lerp(0.0, showAnimation, gui.childShowAnimation)
 
     private val actualHeight get() = height + padding * 2 * isOpen.toInt()
     private var renderHeightAnimation by animation.exp({ 0.0 }, ::actualHeight, 0.6, ::isOpen)
-    private val renderHeight get() = lerp(0.0, renderHeightAnimation, showAnimation)
+    private val renderHeight get() = lerp(0.0, renderHeightAnimation, childShowAnimation)
 
     val contentComponents = ChildLayer.Drawable<T>(gui, this, contentLayer, ::contentRect)
 
@@ -71,7 +70,7 @@ abstract class WindowComponent <T : ChildComponent> (
             roundRadius = ClickGui.windowRadius
             shade = GuiSettings.shadeBackground
 
-            val alpha = (gui.showAnimation * 2.0).coerceIn(0.0, 1.0)
+            val alpha = (gui.childShowAnimation * 2.0).coerceIn(0.0, 1.0)
             color(GuiSettings.backgroundColor.multAlpha(alpha))
         }
 
@@ -81,15 +80,15 @@ abstract class WindowComponent <T : ChildComponent> (
             outerGlow = ClickGui.windowRadius
             shade = GuiSettings.shade
 
-            val alpha = (gui.showAnimation * 2.0).coerceIn(0.0, 1.0)
+            val alpha = (gui.childShowAnimation * 2.0).coerceIn(0.0, 1.0)
             color(GuiSettings.mainColor.multAlpha(alpha))
         }
 
         // Title
         titleFont = renderer.font {
             text = title
             position = titleBar.center - widthVec * 0.5
-            color = Color.WHITE.setAlpha(gui.showAnimation)
+            color = Color.WHITE.setAlpha(gui.childShowAnimation)
         }
     }
 

common/src/main/kotlin/com/lambda/gui/api/component/button/ButtonComponent.kt

@@ -19,7 +19,6 @@ abstract class ButtonComponent(
     abstract val size: Vec2d
 
     abstract val text: String
-    protected open val textY: Double get() = rect.size.y
     protected abstract var activeAnimation: Double
 
     private val actualSize get() = Vec2d(if (size.x == FILL_PARENT) owner.rect.size.x else size.x, size.y)
@@ -32,7 +31,8 @@ abstract class ButtonComponent(
     private var hoverFontAnimation by animation.exp(0.0, 1.0, 0.5, ::renderHovered)
     private var pressAnimation by animation.exp(0.0, 1.0, 0.5, ::pressed)
     protected val interactAnimation get() = lerp(hoverRectAnimation, 1.5, pressAnimation) * 0.4
-    override val showAnimation: Double get() = owner.showAnimation
+    override val childShowAnimation: Double get() = owner.childShowAnimation
+    protected open val showAnimation get() = owner.childShowAnimation
 
     private var lastHoveredTime = 0L
     private val renderHovered get() = hovered || System.currentTimeMillis() - lastHoveredTime < 110
@@ -51,7 +51,7 @@ abstract class ButtonComponent(
             position = hoverRect.shrink(interactAnimation)
             shade = GuiSettings.shade
 
-            val alpha = interactAnimation * 0.2
+            val alpha = interactAnimation * 0.2 * showAnimation
             color(GuiSettings.mainColor.multAlpha(alpha))
         }
 
@@ -63,7 +63,7 @@ abstract class ButtonComponent(
             color = lerp(Color.WHITE, GuiSettings.mainColor, activeAnimation).multAlpha(showAnimation)
 
             val x = ClickGui.windowPadding + interactAnimation + hoverFontAnimation
-            position = rect.leftTop + Vec2d(x, textY)
+            position = rect.leftTop + Vec2d(x, rect.size.y * 0.5)
         }
     }
 

common/src/main/kotlin/com/lambda/gui/api/component/button/ListButton.kt

@@ -4,19 +4,23 @@ import com.lambda.graphics.animation.Animation.Companion.exp
 import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.component.core.list.ChildLayer
 import com.lambda.module.modules.client.ClickGui
-import com.lambda.util.math.MathUtils.toInt
+import com.lambda.util.math.MathUtils.lerp
 import com.lambda.util.math.Vec2d
 
 abstract class ListButton(owner: ChildLayer.Drawable<*>) : ButtonComponent(owner) {
-    override val position get() = Vec2d(0.0, renderHeightOffset)
+    override val position get() = Vec2d(0.0, lerp(0.0, renderHeightOffset, owner.childShowAnimation))
     override val size get() = Vec2d(FILL_PARENT, ClickGui.buttonHeight)
 
+    open val listStep get() = ClickGui.buttonStep
+
     var heightOffset = 0.0
-    protected open val targetHeightOffset get() = heightOffset * owner.showAnimation * owner.isActive.toInt()
-    private var renderHeightOffset by animation.exp(::targetHeightOffset, 0.7)
+    protected open var renderHeightOffset by animation.exp(::heightOffset, 0.9)
 
     override fun onEvent(e: GuiEvent) {
+        if (e is GuiEvent.Show) {
+            heightOffset = 0.0
+            renderHeightOffset = 0.0
+        }
         super.onEvent(e)
-        if (e is GuiEvent.Show) renderHeightOffset = 0.0
     }
 }

common/src/main/kotlin/com/lambda/gui/api/component/core/IComponent.kt

@@ -5,7 +5,7 @@ import com.lambda.util.math.Rect
 
 interface IComponent {
     val isActive: Boolean get() = true
-    val showAnimation: Double get() = 1.0
+    val childShowAnimation: Double get() = 1.0
     val rect: Rect
 
     fun onEvent(e: GuiEvent)

common/src/main/kotlin/com/lambda/gui/api/component/core/list/ChildLayer.kt

@@ -14,7 +14,7 @@ open class ChildLayer <T : ChildComponent> (
     private val childAccessible: (T) -> Boolean = { true }
 ) : IComponent {
     override val isActive get() = owner.isActive
-    override val showAnimation get() = owner.showAnimation
+    override val childShowAnimation get() = owner.childShowAnimation
     override val rect get() = childRect()
     val children = mutableListOf<T>()
 

common/src/main/kotlin/com/lambda/gui/impl/clickgui/AbstractClickGui.kt

@@ -13,7 +13,7 @@ abstract class AbstractClickGui(name: String = "ClickGui") : LambdaGui(name, Cli
     private var activeWindow: WindowComponent<*>? = null
     private var closing = false
 
-    final override var showAnimation by animation.exp(0.0, 1.0, {
+    final override var childShowAnimation by animation.exp(0.0, 1.0, {
         if (closing) ClickGui.closeSpeed else ClickGui.openSpeed
     }) { !closing }; private set
 
@@ -31,11 +31,11 @@ abstract class AbstractClickGui(name: String = "ClickGui") : LambdaGui(name, Cli
             is GuiEvent.Show -> {
                 activeWindow = null
                 closing = false
-                showAnimation = 0.0
+                childShowAnimation = 0.0
             }
 
             is GuiEvent.Tick -> {
-                if (closing && showAnimation < 0.01) mc.setScreen(null)
+                if (closing && childShowAnimation < 0.01) mc.setScreen(null)
             }
 
             is GuiEvent.MouseClick -> {

common/src/main/kotlin/com/lambda/gui/impl/clickgui/buttons/ModuleButton.kt

@@ -1,39 +1,45 @@
 package com.lambda.gui.impl.clickgui.buttons
 
+import com.lambda.config.settings.comparable.BooleanSetting
 import com.lambda.graphics.animation.Animation.Companion.exp
 import com.lambda.graphics.gl.Scissor.scissor
 import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.component.button.ListButton
 import com.lambda.gui.api.component.core.list.ChildLayer
 import com.lambda.gui.api.layer.RenderLayer
+import com.lambda.gui.impl.clickgui.buttons.setting.BooleanButton
 import com.lambda.module.Module
 import com.lambda.module.modules.client.GuiSettings
 import com.lambda.util.Mouse
 import com.lambda.util.math.ColorUtils.multAlpha
 import com.lambda.util.math.MathUtils.lerp
-import com.lambda.util.math.MathUtils.toInt
+import com.lambda.util.math.Rect
 import com.lambda.util.math.Vec2d
 import kotlin.math.abs
 
 class ModuleButton(val module: Module, owner: ChildLayer.Drawable<*>) : ListButton(owner) {
     override val text get() = module.name
-    private val active get() = module.isEnabled
+    private val enabled get() = module.isEnabled
 
-    override val size: Vec2d get() = super.size + Vec2d(0.0, renderHeight)
-    override val textY: Double get() = super.size.y * 0.5
+    override var activeAnimation by animation.exp(0.0, 1.0, 0.15, ::enabled)
+    private val toggleFxDirection by animation.exp(0.0, 1.0, 0.7, ::enabled)
 
-    override var activeAnimation by animation.exp(0.0, 1.0, 0.15, ::active)
-    private val toggleFxDirection by animation.exp(0.0, 1.0, 0.7, ::active)
+    override val listStep: Double get() = super.listStep * 2.0 + renderHeight
 
     private var isOpen = false
     override val isActive get() = isOpen
 
+    private val childShowAnimation0 by animation.exp(0.0, 1.0, 0.7, ::isOpen)
+    override val childShowAnimation get() = lerp(0.0, childShowAnimation0, owner.childShowAnimation)
+
     private var settingsHeight = 0.0
     private var renderHeight by animation.exp(::settingsHeight, 0.6)
-    private val settingsRect get() = rect.moveFirst(Vec2d(0.0, super.size.y))
+    private val settingsRect get() = rect
+        .moveFirst(Vec2d(childShowAnimation * 2.0, size.y + super.listStep))
+        .moveSecond(Vec2d(0.0, listStep))
 
     private val settingsRenderer = RenderLayer()
-    private val settingsLayer = ChildLayer.Drawable<SettingButton<*, *>>(owner.gui, this, settingsRenderer, ::settingsRect)
+    private val settingsLayer = ChildLayer.Drawable(owner.gui, this, settingsRenderer, ::settingsRect, SettingButton<*, *>::visible)
 
     init {
         // Toggle fx
@@ -56,36 +62,72 @@ class ModuleButton(val module: Module, owner: ChildLayer.Drawable<*>) : ListButt
             shade = GuiSettings.shade
             colorH(leftColor, rightColor)
         }
+
+        // Line
+        renderer.filled {
+            val pos1 = Vec2d(rect.left, settingsRect.top)
+            val pos2 = Vec2d(rect.left + childShowAnimation * 1.0, settingsRect.bottom)
+            val color = GuiSettings.mainColor.multAlpha(childShowAnimation * 0.6)
+
+            position = Rect(pos1, pos2)
+
+            shade = GuiSettings.shade
+            color(color)
+        }
+
+        module.settings.mapNotNull {
+            when (it) {
+                is BooleanSetting -> BooleanButton(it, settingsLayer)
+                else -> null
+            }
+        }.forEach(settingsLayer::addChild)
     }
 
     override fun onEvent(e: GuiEvent) {
-        super.onEvent(e)
-
         when (e) {
             is GuiEvent.Show -> {
                 isOpen = false
-                renderHeight = 0.0
+                updateHeight(true)
             }
 
             is GuiEvent.Tick -> {
-                updateSettingsHeight()
+                if (renderHeight > 0.5) {
+                    updateHeight()
+                }
             }
 
             is GuiEvent.Render -> {
-                scissor(settingsRect) {
-                    settingsRenderer.render()
-                    settingsLayer.onEvent(e)
+                var y = 0.0
+                settingsLayer.children.filter(SettingButton<*, *>::visible).forEach { button ->
+                    button.heightOffset = y
+                    y += button.size.y + button.listStep
+                }
+
+                if (renderHeight > 0.5) {
+                    scissor(settingsRect) {
+                        settingsLayer.onEvent(e)
+                        settingsRenderer.render()
+                    }
                 }
+
                 return
             }
         }
+
+        super.onEvent(e)
+        settingsLayer.onEvent(e)
     }
 
-    private fun updateSettingsHeight() {
-        /*val c = settingsLayer.children
-        settingsHeight = c.sumOf { it.size.y } + ((c.size - 1) * ClickGui.buttonStep).coerceAtLeast(0.0)*/
+    private fun updateHeight(forceAnimation: Boolean = false) {
+        settingsHeight = if (isOpen) {
+            var lastStep = 0.0
+            settingsLayer.children
+                .filter(SettingButton<*, *>::visible)
+                .sumOf {  lastStep = it.listStep;  it.size.y + it.listStep } - lastStep
+        }
+        else 0.0
 
-        settingsHeight = 30.0 * isOpen.toInt()
+        if (forceAnimation) renderHeight = settingsHeight
     }
 
     override fun performClickAction(e: GuiEvent.MouseClick) {
@@ -97,7 +139,8 @@ class ModuleButton(val module: Module, owner: ChildLayer.Drawable<*>) : ListButt
                 if (abs(targetHeight - renderHeight) > 1) return
 
                 isOpen = !isOpen
-                updateSettingsHeight()
+                if (isOpen) settingsLayer.onEvent(GuiEvent.Show())
+                updateHeight()
             }
         }
     }

common/src/main/kotlin/com/lambda/gui/impl/clickgui/buttons/SettingButton.kt

@@ -2,27 +2,23 @@ package com.lambda.gui.impl.clickgui.buttons
 
 import com.lambda.config.AbstractSetting
 import com.lambda.graphics.animation.Animation.Companion.exp
-import com.lambda.gui.api.GuiEvent
 import com.lambda.gui.api.component.button.ListButton
 import com.lambda.gui.api.component.core.list.ChildLayer
 import com.lambda.util.math.MathUtils.lerp
-import com.lambda.util.math.MathUtils.toInt
 
 abstract class SettingButton <V : Any, T : AbstractSetting<V>> (
     val setting: T,
     owner: ChildLayer.Drawable<*>
 ): ListButton(owner) {
     protected var value by setting
-    var visible = false
 
-    private var visibilityAnimation by animation.exp({ 0.0 }, { 1.0 }, { if (visible) 0.2 else 0.8 }, ::visible)
-    override val showAnimation get() = lerp(0.0, super.showAnimation, visibilityAnimation)
+    val visible; get() = setting.visibility()
 
-    override var accessible: Boolean = false; get() = field && visible
+    private var visibilityAnimation by animation.exp(0.0, 1.0, 0.7, ::visible)
+    override val showAnimation get() = lerp(0.0, super.showAnimation, visibilityAnimation)
+    override var activeAnimation = 0.0
 
-    override fun onEvent(e: GuiEvent) {
-        if (e is GuiEvent.Show || e is GuiEvent.Tick) visible = setting.visibility()
-        if (e is GuiEvent.Show) visibilityAnimation = visible.toInt().toDouble()
-        super.onEvent(e)
-    }
+    override var renderHeightOffset
+        get() = heightOffset + lerp(-size.y, 0.0, visibilityAnimation)
+        set(value) { heightOffset = value }
 }