GUI Implementation

Added groups
Added button "option"
Added test mod

9 files changed, 730 insertions, 0 deletions

diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java
new file mode 100644
index 0000000..66e8e35
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/ActionControl.java
@@ -0,0 +1,58 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.ButtonOption;
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+public class ActionControl implements Control<Runnable> {
+    private final ButtonOption option;
+    private final Text executeText;
+
+    public ActionControl(ButtonOption option) {
+        this(option, Text.translatable("yacl.control.action.execute"));
+    }
+
+    public ActionControl(ButtonOption option, Text executeText) {
+        this.option = option;
+        this.executeText = executeText;
+
+    }
+
+    @Override
+    public ButtonOption option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return executeText;
+    }
+
+    @Override
+    public ControlWidget<ActionControl> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new ActionControlElement(this, screen, widgetDimension);
+    }
+
+    public static class ActionControlElement extends ControlWidget<ActionControl> {
+        public ActionControlElement(ActionControl control, Screen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (isMouseOver(mouseX, mouseY)) {
+                playDownSound();
+                control.option().action().run();
+                return true;
+            }
+            return false;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java b/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java
new file mode 100644
index 0000000..be05ba4
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/ControlWidget.java
@@ -0,0 +1,125 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.AbstractWidget;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.screen.narration.NarrationMessageBuilder;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.OrderedText;
+import net.minecraft.text.Text;
+
+import java.util.List;
+
+public abstract class ControlWidget<T extends Control<?>> extends AbstractWidget {
+    protected final T control;
+    protected final List<OrderedText> wrappedDescription;
+
+    public Dimension<Integer> dim;
+    protected final Screen screen;
+
+    protected boolean hovered = false;
+    protected float hoveredTicks = 0;
+
+    public ControlWidget(T control, Screen screen, Dimension<Integer> dim) {
+        this.control = control;
+        this.dim = dim;
+        this.screen = screen;
+        this.wrappedDescription = textRenderer.wrapLines(control.option().tooltip(), screen.width / 2);
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        hovered = isMouseOver(mouseX, mouseY);
+        if (hovered) {
+            hoveredTicks += delta;
+        } else {
+            hoveredTicks = 0;
+        }
+
+        Text name = control.option().name();
+        String nameString = name.getString();
+
+        boolean firstIter = true;
+        while (textRenderer.getWidth(nameString) > dim.width() - getControlWidth() - getXPadding() - 7) {
+            nameString = nameString.substring(0, nameString.length() - (firstIter ? 2 : 5)).trim();
+            nameString += "...";
+
+            firstIter = false;
+        }
+
+        Text shortenedName = Text.literal(nameString).fillStyle(name.getStyle());
+
+        drawButtonRect(matrices, dim.x(), dim.y(), dim.xLimit(), dim.yLimit(), hovered);
+        matrices.push();
+        matrices.translate(dim.x() + getXPadding(), getTextY(), 0);
+        textRenderer.drawWithShadow(matrices, shortenedName, 0, 0, -1);
+        matrices.pop();
+
+        drawValueText(matrices);
+        if (hovered) {
+            drawHoveredControl(matrices, mouseX, mouseY, delta);
+        }
+
+        if (hoveredTicks > 40) {
+            screen.renderOrderedTooltip(matrices, wrappedDescription, mouseX, mouseY);
+        }
+    }
+
+    protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+
+    }
+
+    protected void drawValueText(MatrixStack matrices) {
+        Text valueText = control.formatValue();
+        matrices.push();
+        matrices.translate(dim.xLimit() - textRenderer.getWidth(valueText) - getXPadding(), getTextY(), 0);
+        textRenderer.drawWithShadow(matrices, valueText, 0, 0, -1);
+        matrices.pop();
+    }
+
+    @Override
+    public boolean isMouseOver(double mouseX, double mouseY) {
+        return this.dim.isPointInside((int) mouseX, (int) mouseY);
+    }
+
+    protected int getControlWidth() {
+        return hovered ? getHoveredControlWidth() : getUnhoveredControlWidth();
+    }
+
+    protected abstract int getHoveredControlWidth();
+
+    protected int getUnhoveredControlWidth() {
+        return textRenderer.getWidth(control.formatValue());
+    }
+
+    protected int getXPadding() {
+        return 5;
+    }
+
+    protected int getYPadding() {
+        return 2;
+    }
+
+    protected void drawOutline(MatrixStack matrices, int x1, int y1, int x2, int y2, int width, int color) {
+        DrawableHelper.fill(matrices, x1, y1, x2, y1 + width, color);
+        DrawableHelper.fill(matrices, x2, y1, x2 - width, y2, color);
+        DrawableHelper.fill(matrices, x1, y2, x2, y2 - width, color);
+        DrawableHelper.fill(matrices, x1, y1, x1 + width, y2, color);
+    }
+
+    protected float getTextY() {
+        return dim.y() + dim.height() / 2f - textRenderer.fontHeight / 2f;
+    }
+
+    @Override
+    public SelectionType getType() {
+        return hovered ? SelectionType.HOVERED : SelectionType.NONE;
+    }
+
+    @Override
+    public void appendNarrations(NarrationMessageBuilder builder) {
+
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java
new file mode 100644
index 0000000..d032937
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/EnumControl.java
@@ -0,0 +1,77 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.NameableEnum;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+import java.util.function.Function;
+
+public class EnumControl<T extends Enum<T>> implements Control<T> {
+    private final Option<T> option;
+    private final Function<T, Text> valueFormatter;
+    private final Class<T> enumClass;
+
+    public EnumControl(Option<T> option, Class<T> enumClass) {
+        this(option, enumClass, value -> {
+            if (value instanceof NameableEnum nameableEnum)
+                return nameableEnum.getDisplayName();
+            return Text.of(value.name());
+        });
+    }
+
+    public EnumControl(Option<T> option, Class<T> enumClass, Function<T, Text> valueFormatter) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+        this.enumClass = enumClass;
+    }
+
+    @Override
+    public Option<T> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public ControlWidget<EnumControl<T>> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new EnumControlElement<>(this, screen, widgetDimension, enumClass.getEnumConstants());
+    }
+
+    public static class EnumControlElement<T extends Enum<T>> extends ControlWidget<EnumControl<T>> {
+        private final T[] values;
+
+        public EnumControlElement(EnumControl<T> control, Screen screen, Dimension<Integer> dim, T[] values) {
+            super(control, screen, dim);
+            this.values = values;
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY) || (button != 0 && button != 1))
+                return false;
+
+            playDownSound();
+
+            int change = button == 1 || Screen.hasShiftDown() ? -1 : 1;
+            int targetIdx = control.option().pendingValue().ordinal() + change;
+            if (targetIdx >= values.length) {
+                targetIdx -= values.length;
+            } else if (targetIdx < 0) {
+                targetIdx += values.length;
+            }
+            control.option().requestSet(values[targetIdx]);
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return getUnhoveredControlWidth();
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java
new file mode 100644
index 0000000..fb0e595
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/TickBoxControl.java
@@ -0,0 +1,100 @@
+package dev.isxander.yacl.gui.controllers;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.Option;
+import dev.isxander.yacl.api.utils.Dimension;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
+
+import java.util.function.Function;
+
+public class TickBoxControl implements Control<Boolean> {
+
+    public static final Function<Boolean, Text> ON_OFF_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.on").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.off").formatted(Formatting.RED);
+
+    public static final Function<Boolean, Text> TRUE_FALSE_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.true").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.false").formatted(Formatting.RED);
+
+    public static final Function<Boolean, Text> YES_NO_FORMATTER = (state) ->
+            state
+                    ? Text.translatable("yacl.control.tickbox.yes").formatted(Formatting.GREEN)
+                    : Text.translatable("yacl.control.tickbox.no").formatted(Formatting.RED);
+
+    private final Option<Boolean> option;
+    private final Function<Boolean, Text> valueFormatter;
+
+    public TickBoxControl(Option<Boolean> option) {
+        this(option, ON_OFF_FORMATTER);
+    }
+
+    public TickBoxControl(Option<Boolean> option, Function<Boolean, Text> valueFormatter) {
+        this.option = option;
+        this.valueFormatter = valueFormatter;
+
+    }
+
+    @Override
+    public Option<Boolean> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public ControlWidget<TickBoxControl> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new TickBoxControlElement(this, screen, widgetDimension);
+    }
+
+    public static class TickBoxControlElement extends ControlWidget<TickBoxControl> {
+        private TickBoxControlElement(TickBoxControl control, Screen screen, Dimension<Integer> dim) {
+            super(control, screen, dim);
+        }
+
+        @Override
+        protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+            int outlineSize = 10;
+            int outlineX1 = dim.xLimit() - getXPadding() - outlineSize;
+            int outlineY1 = dim.centerY() - outlineSize / 2;
+            int outlineX2 = dim.xLimit() - getXPadding();
+            int outlineY2 = dim.centerY() + outlineSize / 2;
+            drawOutline(matrices, outlineX1 + 1, outlineY1 + 1, outlineX2 + 1, outlineY2 + 1, 1, 0xFF404040);
+            drawOutline(matrices, outlineX1, outlineY1, outlineX2, outlineY2, 1, -1);
+            if (control.option().pendingValue()) {
+                DrawableHelper.fill(matrices, outlineX1 + 3, outlineY1 + 3, outlineX2 - 1, outlineY2 - 1, 0xFF404040);
+                DrawableHelper.fill(matrices, outlineX1 + 2, outlineY1 + 2, outlineX2 - 2, outlineY2 - 2, -1);
+            }
+        }
+
+        @Override
+        protected void drawValueText(MatrixStack matrices) {
+            if (!hovered)
+                super.drawValueText(matrices);
+        }
+
+        @Override
+        public boolean mouseClicked(double mouseX, double mouseY, int button) {
+            if (!isMouseOver(mouseX, mouseY))
+                return false;
+
+            control.option().requestSet(!control.option().pendingValue());
+            playDownSound();
+            return true;
+        }
+
+        @Override
+        protected int getHoveredControlWidth() {
+            return 10;
+        }
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java
new file mode 100644
index 0000000..5aaa6c4
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/DoubleSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class DoubleSliderControl implements ISliderControl<Double> {
+    public static final Function<Double, Text> DEFAULT_FORMATTER = value -> Text.of(String.format("%.2f", value));
+
+    private final Option<Double> option;
+
+    private final double min, max, interval;
+
+    private final Function<Double, Text> valueFormatter;
+
+    public DoubleSliderControl(Option<Double> option, double min, double max, double interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public DoubleSliderControl(Option<Double> option, double min, double max, double interval, Function<Double, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Double> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet(value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply(value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java
new file mode 100644
index 0000000..d74ec33
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/FloatSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class FloatSliderControl implements ISliderControl<Float> {
+    public static final Function<Float, Text> DEFAULT_FORMATTER = value -> Text.of(String.format("%.1f", value));
+
+    private final Option<Float> option;
+
+    private final float min, max, interval;
+
+    private final Function<Float, Text> valueFormatter;
+
+    public FloatSliderControl(Option<Float> option, float min, float max, float interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public FloatSliderControl(Option<Float> option, float min, float max, float interval, Function<Float, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Float> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((float) value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply((float) value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java
new file mode 100644
index 0000000..8c1cdf8
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/ISliderControl.java
@@ -0,0 +1,29 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Control;
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.text.Text;
+
+public interface ISliderControl<T extends Number> extends Control<T> {
+    double min();
+
+    double max();
+
+    double interval();
+
+    default double range() {
+        return max() - min();
+    }
+
+    void setPendingValue(double value);
+    double pendingValue();
+
+    Text getValueText(double value);
+
+    @Override
+    default ControlWidget<?> provideWidget(Screen screen, Dimension<Integer> widgetDimension) {
+        return new SliderControlElement(this, screen, widgetDimension, min(), max(), interval());
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java
new file mode 100644
index 0000000..99c8137
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/IntegerSliderControl.java
@@ -0,0 +1,72 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.Option;
+import net.minecraft.text.Text;
+import org.apache.commons.lang3.Validate;
+
+import java.util.function.Function;
+
+public class IntegerSliderControl implements ISliderControl<Integer> {
+    public static final Function<Integer, Text> DEFAULT_FORMATTER = value -> Text.of(String.valueOf(value));
+
+    private final Option<Integer> option;
+
+    private final int min, max, interval;
+
+    private final Function<Integer, Text> valueFormatter;
+
+    public IntegerSliderControl(Option<Integer> option, int min, int max, int interval) {
+        this(option, min, max, interval, DEFAULT_FORMATTER);
+    }
+
+    public IntegerSliderControl(Option<Integer> option, int min, int max, int interval, Function<Integer, Text> valueFormatter) {
+        Validate.isTrue(max > min, "`max` cannot be smaller than `min`");
+        Validate.isTrue(interval > 0, "`interval` must be more than 0");
+
+        this.option = option;
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+        this.valueFormatter = valueFormatter;
+    }
+
+    @Override
+    public Option<Integer> option() {
+        return option;
+    }
+
+    @Override
+    public Text formatValue() {
+        return valueFormatter.apply(option().pendingValue());
+    }
+
+    @Override
+    public double min() {
+        return min;
+    }
+
+    @Override
+    public double max() {
+        return max;
+    }
+
+    @Override
+    public double interval() {
+        return interval;
+    }
+
+    @Override
+    public void setPendingValue(double value) {
+        option().requestSet((int) value);
+    }
+
+    @Override
+    public double pendingValue() {
+        return option().pendingValue();
+    }
+
+    @Override
+    public Text getValueText(double value) {
+        return valueFormatter.apply((int) value);
+    }
+}
diff --git a/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java b/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java
new file mode 100644
index 0000000..b8dab71
--- /dev/null
+++ b/src/main/java/dev/isxander/yacl/gui/controllers/slider/SliderControlElement.java
@@ -0,0 +1,125 @@
+package dev.isxander.yacl.gui.controllers.slider;
+
+import dev.isxander.yacl.api.utils.Dimension;
+import dev.isxander.yacl.gui.controllers.ControlWidget;
+import net.minecraft.client.gui.DrawableHelper;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.text.Text;
+import net.minecraft.util.math.MathHelper;
+
+public class SliderControlElement extends ControlWidget<ISliderControl<?>> {
+    private final double min, max, interval;
+
+    private float interpolation;
+
+    private Dimension<Integer> sliderBounds;
+
+    private boolean mouseDown = false;
+
+    public SliderControlElement(ISliderControl<?> option, Screen screen, Dimension<Integer> dim, double min, double max, double interval) {
+        super(option, screen, dim);
+        this.min = min;
+        this.max = max;
+        this.interval = interval;
+    }
+
+    @Override
+    public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        super.render(matrices, mouseX, mouseY, delta);
+
+        if (sliderBounds == null)
+            sliderBounds = Dimension.ofInt(dim.xLimit() - getXPadding() - getThumbWidth() / 2 - dim.width() / 3, dim.centerY() - 4, dim.width() / 3, 8);
+        calculateInterpolation();
+    }
+
+    @Override
+    protected void drawHoveredControl(MatrixStack matrices, int mouseX, int mouseY, float delta) {
+        // track
+        DrawableHelper.fill(matrices, sliderBounds.x(), sliderBounds.centerY() - 1, sliderBounds.xLimit(), sliderBounds.centerY(), -1);
+        // track shadow
+        DrawableHelper.fill(matrices, sliderBounds.x() + 1, sliderBounds.centerY(), sliderBounds.xLimit() + 1, sliderBounds.centerY() + 1, 0xFF404040);
+
+        // thumb shadow
+        DrawableHelper.fill(matrices, getThumbX() - getThumbWidth() / 2 + 1, sliderBounds.y() + 1, getThumbX() + getThumbWidth() / 2 + 1, sliderBounds.yLimit() + 1, 0xFF404040);
+        // thumb
+        DrawableHelper.fill(matrices, getThumbX() - getThumbWidth() / 2, sliderBounds.y(), getThumbX() + getThumbWidth() / 2, sliderBounds.yLimit(), -1);
+    }
+
+    @Override
+    protected void drawValueText(MatrixStack matrices) {
+        matrices.push();
+        if (hovered)
+            matrices.translate(-(sliderBounds.width() + 6 + getThumbWidth() / 2f), 0, 0);
+        super.drawValueText(matrices);
+        matrices.pop();
+    }
+
+    @Override
+    public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if (button != 0 || !sliderBounds.isPointInside((int) mouseX, (int) mouseY))
+            return false;
+
+        mouseDown = true;
+
+        setValueFromMouse(mouseX);
+        return true;
+    }
+
+    @Override
+    public boolean mouseDragged(double mouseX, double mouseY, int button, double deltaX, double deltaY) {
+        if (button != 0 || !sliderBounds.isPointInside((int) mouseX, (int) mouseY))
+            return false;
+
+        setValueFromMouse(mouseX);
+        return true;
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        if (!isMouseOver(mouseX, mouseY) || !Screen.hasShiftDown())
+            return false;
+
+        control.setPendingValue(MathHelper.clamp(control.pendingValue() + interval * amount, min, max));
+        calculateInterpolation();
+        return true;
+    }
+
+    @Override
+    public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (mouseDown)
+            playDownSound();
+        mouseDown = false;
+
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    private void setValueFromMouse(double mouseX) {
+        double value = (mouseX - sliderBounds.x()) / sliderBounds.width() * control.range();
+        double roundedValue = min + (interval * Math.round(value / interval));
+        control.setPendingValue(roundedValue);
+        calculateInterpolation();
+    }
+
+    @Override
+    protected int getHoveredControlWidth() {
+        int textWidth = textRenderer.getWidth(getValueText());
+        return hovered ? sliderBounds.width() + textWidth + 6 + getThumbWidth() / 2 : textWidth ;
+    }
+
+    private void calculateInterpolation() {
+        interpolation = (float) ((control.pendingValue() - control.min()) * 1 / control.range());
+    }
+
+    private Text getValueText() {
+        return control.getValueText(control.pendingValue());
+    }
+
+    private int getThumbX() {
+        return (int) (sliderBounds.x() + sliderBounds.width() * interpolation);
+    }
+
+    private int getThumbWidth() {
+        return 4;
+    }
+}