lotsa new features

scroll zoom has individual settings now
fix scroll zoom with some transitions
hold/toggle zoom key
cinematic cam on zoom
update gradle

build.gradle.kts

@@ -13,13 +13,19 @@ repositories {
     mavenCentral()
     maven("https://repo.sk1er.club/repository/maven-public")
     maven("https://maven.terraformersmc.com/releases")
+    maven("https://jitpack.io")
 }
 
 fun DependencyHandlerScope.includeModImplementation(dependency: Any) {
     include(dependency)
     modImplementation(dependency)
 }
 
+fun DependencyHandlerScope.includeImplementation(dependency: Any) {
+    include(dependency)
+    implementation(dependency)
+}
+
 dependencies {
     val kotlinVersion: String by System.getProperties()
     val minecraftVersion: String by project
@@ -38,12 +44,14 @@ dependencies {
 
     includeModImplementation("gg.essential:vigilance-1.18-fabric:+")
     modImplementation("com.terraformersmc:modmenu:3.0.+")
+
+    includeImplementation("com.github.llamalad7:mixinextras:0.0.+")
+    annotationProcessor("com.github.llamalad7:mixinextras:0.0.+")
 }
 
-kotlin {
-    jvmToolchain {
-        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(17))
-    }
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
 }
 
 tasks {

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/java/dev/isxander/zoomify/mixins/MouseMixin.java

@@ -1,6 +1,8 @@
 package dev.isxander.zoomify.mixins;
 
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import dev.isxander.zoomify.Zoomify;
+import dev.isxander.zoomify.config.ZoomifySettings;
 import net.minecraft.client.Mouse;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -23,4 +25,12 @@ private void onMouseScroll(CallbackInfo ci) {
             ci.cancel();
         }
     }
+
+    @ModifyExpressionValue(
+            method = "updateMouse",
+            at = @At(value = "FIELD", target = "Lnet/minecraft/client/option/GameOptions;smoothCameraEnabled:Z")
+    )
+    private boolean smoothCameraIfZoom(boolean original) {
+        return original || (Zoomify.INSTANCE.getZooming() && ZoomifySettings.INSTANCE.getCinematicCam());
+    }
 }

src/main/kotlin/dev/isxander/zoomify/Zoomify.kt

@@ -1,37 +1,50 @@
 package dev.isxander.zoomify
 
+import com.llamalad7.mixinextras.MixinExtrasBootstrap
+import dev.isxander.zoomify.config.ZoomKeyBehaviour
 import dev.isxander.zoomify.config.ZoomifySettings
-import dev.isxander.zoomify.utils.TransitionType
-import dev.isxander.zoomify.utils.getPercent
-import dev.isxander.zoomify.utils.lerp
+import dev.isxander.zoomify.utils.mc
+import dev.isxander.zoomify.zoom.SingleZoomHelper
+import dev.isxander.zoomify.zoom.TieredZoomHelper
 import gg.essential.vigilance.Vigilance
 import net.fabricmc.api.ClientModInitializer
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents
 import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper
 import net.minecraft.client.option.KeyBinding
 import net.minecraft.client.util.InputUtil
-import net.minecraft.util.math.MathHelper
 
 object Zoomify : ClientModInitializer {
-    val zoomKey = KeyBinding("zoomify.zoom", InputUtil.Type.KEYSYM, InputUtil.GLFW_KEY_C, "zoomify.category")
-    private var lastZoomMultiplier = 0.0
+    val zoomKey = KeyBinding("zoomify.key.zoom", InputUtil.Type.KEYSYM, InputUtil.GLFW_KEY_C, "zoomify.key.category")
+    var zooming = false
+
+    private val normalZoomHelper = SingleZoomHelper({ ZoomifySettings.initialZoom.toDouble() }, { ZoomifySettings.zoomSpeed.toDouble() }, { ZoomifySettings.zoomTransition })
+    private val scrollZoomHelper = TieredZoomHelper({ ZoomifySettings.scrollZoomSpeed.toDouble() }, { ZoomifySettings.scrollZoomTransition }, { 6 }, { ZoomifySettings.maxScrollZoom * 5.0 })
     private var scrollSteps = 0
 
     override fun onInitializeClient() {
+        MixinExtrasBootstrap.init()
+
         Vigilance.initialize()
         ZoomifySettings.preload()
 
         KeyBindingHelper.registerKeyBinding(zoomKey)
+
+        ClientTickEvents.END_CLIENT_TICK.register {
+            if (zoomKey.wasPressed() && ZoomifySettings.zoomKeyBehaviour == ZoomKeyBehaviour.TOGGLE) {
+                zooming = !zooming
+            }
+        }
     }
 
     @JvmStatic
     fun getZoomDivisor(tickDelta: Float = 1f): Double {
-        if (!zoomKey.isPressed) scrollSteps = 0
+        if (ZoomifySettings.zoomKeyBehaviour == ZoomKeyBehaviour.HOLD)
+            zooming = zoomKey.isPressed
 
-        val scrollAmt = TransitionType.EASE_OUT_QUAD.apply(getPercent(scrollSteps.toDouble(), 0.0, 6.0)) * (2 * ZoomifySettings.scrollAmount)
-        val targetZoom = if (zoomKey.isPressed) 1.0 + scrollAmt else 0.0
-        lastZoomMultiplier = lerp(lastZoomMultiplier, targetZoom, tickDelta * (ZoomifySettings.zoomSpeed.toDouble() / 50.0))
+        if (!zooming) scrollSteps = 0
 
-        return lerp(1.0, ZoomifySettings.initialZoom.toDouble(), ZoomifySettings.zoomTransition.apply(lastZoomMultiplier))
+        return normalZoomHelper.getZoomDivisor(SingleZoomHelper.SingleZoomParams(zooming, tickDelta)) +
+                scrollZoomHelper.getZoomDivisor(TieredZoomHelper.TieredZoomParams(scrollSteps, tickDelta))
     }
 
     @JvmStatic

src/main/kotlin/dev/isxander/zoomify/config/ZoomKeyBehaviour.kt

@@ -0,0 +1,6 @@
+package dev.isxander.zoomify.config
+
+enum class ZoomKeyBehaviour(val translationKey: String) {
+    HOLD("zoomify.zoom_key_behaviour.hold"),
+    TOGGLE("zoomify.zoom_key_behaviour.toggle")
+}

src/main/kotlin/dev/isxander/zoomify/config/ZoomifySettings.kt

@@ -8,7 +8,15 @@ import java.io.File
 
 object ZoomifySettings : Vigilant(File(mc.runDirectory, "config/zoomify.toml"), "Zoomify") {
     var initialZoom = 4f
-    var scrollAmount = 0.75f
+
+    var maxScrollZoom = 0.75f
+    private var _scrollZoomTransition = TransitionType.LINEAR.ordinal
+    var scrollZoomTransition: TransitionType
+        get() = TransitionType.values()[this._scrollZoomTransition]
+        set(value) {
+            this._scrollZoomTransition = value.ordinal
+        }
+    var scrollZoomSpeed = 0.5f
 
     var zoomSpeed = 0.5f
     private var _zoomTransition = TransitionType.LINEAR.ordinal
@@ -18,13 +26,32 @@ object ZoomifySettings : Vigilant(File(mc.runDirectory, "config/zoomify.toml"),
             this._zoomTransition = value.ordinal
         }
 
+
+    private var _zoomKeyBehaviour = ZoomKeyBehaviour.HOLD.ordinal
+    var zoomKeyBehaviour: ZoomKeyBehaviour
+        get() = ZoomKeyBehaviour.values()[this._zoomKeyBehaviour]
+        set(value) {
+            this._zoomKeyBehaviour = value.ordinal
+        }
+
+    var cinematicCam = false
+
     init {
-        category("zoomify.gui.category.main") {
+        category("zoomify.gui.category.behaviour") {
             decimalSlider(::initialZoom, "zoomify.gui.initialZoom.name", "zoomify.gui.initialZoom.description", min = 1f, max = 10f)
-            percentSlider(::scrollAmount, "zoomify.gui.scrollAmount.name", "zoomify.gui.scrollAmount.description")
-
             percentSlider(::zoomSpeed, "zoomify.gui.zoomSpeed.name", "zoomify.gui.zoomSpeed.description")
             selector(::_zoomTransition, "zoomify.gui.zoomTransition.name", "zoomify.gui.zoomTransition.description", TransitionType.values().map { it.translationKey })
+
+            subcategory("zoomify.gui.subcategory.scrolling") {
+                percentSlider(::maxScrollZoom, "zoomify.gui.maxScrollZoom.name", "zoomify.gui.maxScrollZoom.description")
+                percentSlider(::scrollZoomSpeed, "zoomify.gui.scrollZoomSpeed.name", "zoomify.gui.scrollZoomSpeed.description")
+                selector(::_scrollZoomTransition, "zoomify.gui.scrollZoomTransition.name", "zoomify.gui.scrollZoomTransition.description", TransitionType.values().map { it.translationKey })
+            }
+        }
+
+        category("zoomify.gui.category.controls") {
+            selector(::_zoomKeyBehaviour, "zoomify.gui.zoomKeyBehaviour.name", "zoomify.gui.zoomKeyBehaviour.description", ZoomKeyBehaviour.values().map { it.translationKey })
+            switch(::cinematicCam, "zoomify.gui.cinematicCam.name", "zoomify.gui.cinematicCam.description")
         }
 
         initialize()

src/main/kotlin/dev/isxander/zoomify/utils/TransitionType.kt

@@ -8,7 +8,7 @@ import kotlin.math.sin
 enum class TransitionType(val translationKey: String) : Transition {
     INSTANT("zoomify.transition.instant") {
         override fun apply(t: Double) =
-            1.0
+            throw UnsupportedOperationException("TransitionType.INSTANT does not support apply()")
     },
     LINEAR("zoomify.transition.linear") {
         override fun apply(t: Double) =

src/main/kotlin/dev/isxander/zoomify/zoom/SingleZoomHelper.kt

@@ -0,0 +1,34 @@
+package dev.isxander.zoomify.zoom
+
+import dev.isxander.zoomify.utils.TransitionType
+import dev.isxander.zoomify.utils.lerp
+
+open class SingleZoomHelper(private val _initialZoom: () -> Double, zoomSpeed: () -> Double, transition: () -> TransitionType) : ZoomHelper<SingleZoomHelper.SingleZoomParams>(zoomSpeed, transition) {
+    val initialZoom: Double
+        get() = _initialZoom()
+
+    private var prevZoomDivisor = 0.0
+    private var ticks = 0.0
+
+    override fun getZoomDivisor(params: SingleZoomParams): Double {
+        val zooming = params.zooming
+        val tickDelta = params.tickDelta
+
+        val targetZoom = if (zooming) 1.0 else 0.0
+
+        if (transition == TransitionType.INSTANT) {
+            prevZoomDivisor = targetZoom
+        } else if (targetZoom > prevZoomDivisor) {
+            prevZoomDivisor += zoomSpeed / 20 * tickDelta
+            prevZoomDivisor = prevZoomDivisor.coerceAtMost(targetZoom)
+        } else if (targetZoom < prevZoomDivisor) {
+            prevZoomDivisor -= tickDelta * (zoomSpeed / 20)
+            prevZoomDivisor = prevZoomDivisor.coerceAtLeast(targetZoom)
+        }
+
+        ticks++
+        return lerp(1.0, initialZoom, transition.takeUnless { it == TransitionType.INSTANT }?.apply(prevZoomDivisor) ?: prevZoomDivisor)
+    }
+
+    data class SingleZoomParams(val zooming: Boolean, val tickDelta: Float) : ZoomParams()
+}

src/main/kotlin/dev/isxander/zoomify/zoom/TieredZoomHelper.kt

@@ -0,0 +1,35 @@
+package dev.isxander.zoomify.zoom
+
+import dev.isxander.zoomify.utils.TransitionType
+import dev.isxander.zoomify.utils.lerp
+
+open class TieredZoomHelper(zoomSpeed: () -> Double, transition: () -> TransitionType, private val _maxTiers: () -> Int, private val _maxZoom: () -> Double) : ZoomHelper<TieredZoomHelper.TieredZoomParams>(zoomSpeed, transition) {
+    val maxTiers: Int
+        get() = _maxTiers()
+
+    val maxZoom: Double
+        get() = _maxZoom()
+
+    private var prevZoomDivisor = 0.0
+
+    override fun getZoomDivisor(params: TieredZoomParams): Double {
+        val tier = params.tier
+        val tickDelta = params.tickDelta
+
+        val targetZoom = tier.toDouble() / maxTiers
+
+        if (transition == TransitionType.INSTANT) {
+            prevZoomDivisor = targetZoom
+        } else if (targetZoom > prevZoomDivisor) {
+            prevZoomDivisor += tickDelta * (zoomSpeed / 20)
+            prevZoomDivisor = prevZoomDivisor.coerceAtMost(targetZoom)
+        } else if (targetZoom < prevZoomDivisor) {
+            prevZoomDivisor -= tickDelta * (zoomSpeed / 20)
+            prevZoomDivisor = prevZoomDivisor.coerceAtLeast(targetZoom)
+        }
+
+        return lerp(0.0, maxZoom, transition.takeUnless { it == TransitionType.INSTANT }?.apply(prevZoomDivisor) ?: prevZoomDivisor)
+    }
+
+    data class TieredZoomParams(val tier: Int, val tickDelta: Float) : ZoomParams()
+}

src/main/kotlin/dev/isxander/zoomify/zoom/ZoomHelper.kt

@@ -0,0 +1,15 @@
+package dev.isxander.zoomify.zoom
+
+import dev.isxander.zoomify.utils.TransitionType
+
+abstract class ZoomHelper<T : ZoomHelper.ZoomParams>(private val _zoomSpeed: () -> Double, private val _transition: () -> TransitionType) {
+    val zoomSpeed: Double
+        get() = _zoomSpeed()
+
+    val transition: TransitionType
+        get() = _transition()
+
+    abstract fun getZoomDivisor(params: T): Double
+
+    abstract class ZoomParams
+}

src/main/resources/assets/zoomify/lang/en_us.json

@@ -2,15 +2,25 @@
   "zoomify.key.zoom": "Zooom",
   "zoomify.key.category": "Zoomify",
 
-  "zoomify.gui.category.main": "Behaviour",
+  "zoomify.gui.category.behaviour": "Behaviour",
   "zoomify.gui.initialZoom.name": "Initial Zoom",
   "zoomify.gui.initialZoom.description": "The zoom level when you first zoomify.",
-  "zoomify.gui.scrollAmount.name": "Scroll Amount",
-  "zoomify.gui.scrollAmount.description": "The amount scrolling zooms in or out.",
   "zoomify.gui.zoomSpeed.name": "Zoom Speed",
   "zoomify.gui.zoomSpeed.description": "Speed at which the zoom animation will occur.",
   "zoomify.gui.zoomTransition.name": "Zoom Transition",
   "zoomify.gui.zoomTransition.description": "The transition type used when zooming.",
+  "zoomify.gui.subcategory.scrolling": "Scrolling",
+  "zoomify.gui.maxScrollZoom.name": "Max Scroll Zoom",
+  "zoomify.gui.maxScrollZoom.description": "The maximum zoom level that can be achieved when scrolling.",
+  "zoomify.gui.scrollZoomSpeed.name": "Scroll Zoom Speed",
+  "zoomify.gui.scrollZoomSpeed.description": "Speed at which the scroll zoom animation will occur.",
+  "zoomify.gui.scrollZoomTransition.name": "Scroll Zoom Transition",
+  "zoomify.gui.scrollZoomTransition.description": "The transition type used when scrolling to zoom.",
+  "zoomify.gui.category.controls": "Controls",
+  "zoomify.gui.zoomKeyBehaviour.name": "Zoom Key Behaviour",
+  "zoomify.gui.zoomKeyBehaviour.description": "The behaviour of the zoom key.",
+  "zoomify.gui.cinematicCam.name": "Cinematic Camera",
+  "zoomify.gui.cinematicCam.description": "Make the camera move smoothly when zoomed.",
 
   "zoomify.transition.instant": "Instant",
   "zoomify.transition.linear": "Linear",
@@ -22,5 +32,8 @@
   "zoomify.transition.ease_in_out_quad": "Ease In Out Quad",
   "zoomify.transition.ease_in_cubic": "Ease In Cubic",
   "zoomify.transition.ease_out_cubic": "Ease Out Cubic",
-  "zoomify.transition.ease_in_out_cubic": "Ease In Out Cubic"
+  "zoomify.transition.ease_in_out_cubic": "Ease In Out Cubic",
+
+  "zoomify.zoom_key_behaviour.hold": "Hold",
+  "zoomify.zoom_key_behaviour.toggle": "Toggle"
 }