Merge pull request #17 from Avanatiker/feature/renderer

GUI Rewrite

Author: Avanatiker

common/src/main/java/com/lambda/mixin/input/KeyboardMixin.java

@@ -14,6 +14,6 @@ public class KeyboardMixin {
     void onKey(long window, int key, int scancode, int action, int modifiers, CallbackInfo ci) {
         if (key <= 0) return;
         if (action != 1) return;
-        EventFlow.post(new KeyPressEvent(key));
+        EventFlow.post(new KeyPressEvent(key, scancode, action, modifiers));
     }
 }

common/src/main/kotlin/com/lambda/config/AbstractSetting.kt

@@ -56,11 +56,13 @@ abstract class AbstractSetting<T : Any>(
     val description: String,
     val visibility: () -> Boolean,
 ) : Jsonable, Nameable {
-    private val listeners = mutableListOf<(from: T, to: T) -> Unit>()
+    private val listeners = mutableListOf<ValueListener<T>>()
 
     var value: T by Delegates.observable(defaultValue) { _, from, to ->
-        if (from == to) return@observable
-        listeners.forEach { it(from, to) }
+        listeners.forEach {
+            if (it.requiresValueChange && from == to) return@forEach
+            it.execute(from, to)
+        }
     }
 
     private val isVisible get() = visibility()
@@ -79,18 +81,24 @@ abstract class AbstractSetting<T : Any>(
     }
 
     fun onValueChange(block: SafeContext.(from: T, to: T) -> Unit) {
-        listeners.add { from, to ->
+        listeners.add(ValueListener(true) { from, to ->
             runSafe {
                 block(from, to)
             }
-        }
+        })
     }
 
     fun onValueChangeUnsafe(block: (from: T, to: T) -> Unit) {
-        listeners.add(block)
+        listeners.add(ValueListener(true, block))
+    }
+
+    fun onValueSet(block: (from: T, to: T) -> Unit) {
+        listeners.add(ValueListener(false, block))
     }
 
     private fun reset() {
         value = defaultValue
     }
+
+    class ValueListener <T> (val requiresValueChange: Boolean, val execute: (from: T, to: T) -> Unit)
 }

common/src/main/kotlin/com/lambda/config/serializer/KeyCodeSerializer.kt

@@ -4,21 +4,20 @@ import com.google.gson.*
 import com.lambda.util.KeyCode
 import java.lang.reflect.Type
 
-// ToDo: Use key lookup table to store actual key names
 object KeyCodeSerializer : JsonSerializer<KeyCode>, JsonDeserializer<KeyCode> {
     override fun serialize(
         src: KeyCode?,
         typeOfSrc: Type?,
         context: JsonSerializationContext?,
     ): JsonElement =
         src?.let {
-            JsonPrimitive(it.key)
+            JsonPrimitive(it.name)
         } ?: JsonNull.INSTANCE
 
     override fun deserialize(
         json: JsonElement?,
         typeOfT: Type?,
         context: JsonDeserializationContext?,
     ): KeyCode =
-        json?.asInt?.let { KeyCode(it) } ?: throw JsonParseException("Invalid key code format")
+        json?.asString?.let(KeyCode::fromKeyName) ?: throw JsonParseException("Invalid key code format")
 }

common/src/main/kotlin/com/lambda/config/settings/comparable/EnumSetting.kt

@@ -1,8 +1,6 @@
 package com.lambda.config.settings.comparable
 
 import com.lambda.config.AbstractSetting
-import com.lambda.util.Nameable
-import java.util.*
 
 class EnumSetting<T : Enum<T>>(
     override val name: String,
@@ -14,12 +12,6 @@ class EnumSetting<T : Enum<T>>(
     description,
     visibility,
 ) {
-    val displayValue get() = (value as? Nameable)?.name ?: value.name.split('_').joinToString(" ") { low ->
-        low.lowercase().replaceFirstChar {
-            if (it.isLowerCase()) it.titlecase(Locale.getDefault()) else it.toString()
-        }
-    }
-
     val enumValues: Array<T> = defaultValue.declaringJavaClass.enumConstants
 
     fun next() {

common/src/main/kotlin/com/lambda/event/events/KeyPressEvent.kt

@@ -3,13 +3,25 @@ package com.lambda.event.events
 import com.lambda.event.EventFlow
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
+import com.lambda.util.KeyCode
 
 /**
  * A class representing a [KeyPressEvent] in the event system ([EventFlow]).
  *
  * A [KeyPressEvent] is a type of event that is triggered when a key is pressed.
  * It implements [ICancellable] interface, which means the event can be cancelled.
  *
- * @property key The key code of the key that was pressed.
+ * @property keyCode The key code of the key that was pressed.
+ * @property scanCode The scan code of the key that was pressed.
+ * @property action The action that was performed on the key.
+ * @property modifiers The modifiers that were active when the key was pressed.
  */
-class KeyPressEvent(val key: Int) : ICancellable by Cancellable()
+data class KeyPressEvent(
+    val keyCode: Int,
+    val scanCode: Int,
+    val action: Int,
+    val modifiers: Int,
+) : ICancellable by Cancellable() {
+    val translated: KeyCode
+        get() = KeyCode.virtualMapUS(keyCode, scanCode)
+}

common/src/main/kotlin/com/lambda/graphics/animation/Animation.kt

@@ -13,7 +13,9 @@ class Animation(initialValue: Double, val update: (Double) -> Double) {
     operator fun getValue(thisRef: Any?, property: KProperty<*>) =
         lerp(prevValue, currValue, mc.partialTicks)
 
-    operator fun setValue(thisRef: Any?, property: KProperty<*>, valueIn: Double) {
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, valueIn: Double) = setValue(valueIn)
+
+    fun setValue(valueIn: Double) {
         prevValue = valueIn
         currValue = valueIn
     }

common/src/main/kotlin/com/lambda/graphics/buffer/vao/VAO.kt

@@ -197,7 +197,7 @@ class VAO(
         indicesCount = 0
     }
 
-    fun destroy() {
+    protected fun finalize() {
         runOnGameThread {
             glDeleteBuffers(ibo)
             glDeleteBuffers(vbo)

common/src/main/kotlin/com/lambda/graphics/gl/Matrices.kt

@@ -15,6 +15,10 @@ object Matrices {
         stack.last().translate(x, y, z)
     }
 
+    fun scale(x: Double, y: Double, z: Double) {
+        stack.last().scale(x.toFloat(), y.toFloat(), z.toFloat())
+    }
+
     fun scale(x: Float, y: Float, z: Float) {
         stack.last().scale(x, y, z)
     }
@@ -32,6 +36,12 @@ object Matrices {
         stack.addLast(Matrix4f(entry))
     }
 
+    fun push(block: Matrices.() -> Unit) {
+        push()
+        this.block()
+        pop()
+    }
+
     fun pop() {
         stack.removeLast()
     }