alpha2

README.MD

@@ -13,5 +13,6 @@
 - Cloak rendering: `IIpho3nix` & `Dhyan Blum`
 - Who Am I: `FokshaWasTaken`
 - Panton font (ui): `Ivan Petrov` & `Fontfabric`
+- Panorama: https://www.planetminecraft.com/texture-pack/minecraft-cavesand-cliffs-part-ii-main-menu-panorama/
 
 If any of the code or assets are in your name and you want to remove them, please submit an issue, we are still in alpha to have any artists so we would also appreciate if you could help us make some cosmetics

gradle.properties

@@ -8,7 +8,7 @@ org.gradle.jvmargs=-Xmx1G
 	loader_version=0.16.10
 
 # Mod Properties
-	mod_version = 0.0.1-alpha1
+	mod_version = 0.0.1-alpha2
 	maven_group = me.iipho3nix
 	archives_base_name = saturnclient
 

src/main/java/org/saturnclient/modules/ModManager.java

@@ -13,7 +13,8 @@ import org.saturnclient.ui2.RenderScope;
 
 public class ModManager {
     public static Module[] MODS = {
-        new Crosshair()
+        new Crosshair(),
+        new AutoSprint(),
     };
 
     public static void init() {

src/main/java/org/saturnclient/modules/mods/AutoSprint.java

@@ -0,0 +1,36 @@
+package org.saturnclient.modules.mods;
+
+import java.util.Objects;
+
+import org.saturnclient.modules.Module;
+import org.saturnclient.saturnclient.SaturnClient;
+import org.saturnclient.saturnclient.config.Property;
+
+public class AutoSprint extends Module {
+    private static Property<Boolean> enabled = new Property<>(true);
+
+    public AutoSprint() {
+        super("Auto Sprint", "sprint", enabled.named("Enabled"));
+    }
+
+    @Override
+    public void tick() {
+        if (SaturnClient.client.player == null || SaturnClient.client.getNetworkHandler() == null) {
+            return;
+        }
+        if (SaturnClient.client.options.forwardKey.isPressed() && !SaturnClient.client.options.backKey.isPressed() && !SaturnClient.client.player.isSneaking() &&
+            !SaturnClient.client.player.horizontalCollision) {
+            Objects.requireNonNull(SaturnClient.client.player).setSprinting(true);
+        }
+    }
+
+    @Override
+    public boolean isEnabled() {
+        return enabled.value;
+    }
+
+    @Override
+    public void setEnabled(boolean e) {
+        enabled.value = e;
+    }
+}

src/main/java/org/saturnclient/modules/mods/Crosshair.java

@@ -25,10 +25,10 @@ public class Crosshair extends Module {
             int scaledWidth = 15;
             int scaledHeight = 15;
 
-            scope.drawTexture(RenderLayer::getCrosshair, Textures.CROSSHAIR_RANGE,
+            scope.setRenderLayer(RenderLayer::getCrosshair);
+            scope.drawTexture(Textures.CROSSHAIR_RANGE,
                     (scope.getScaledWindowWidth() - scaledWidth) / 2,
-                    (scope.getScaledWindowHeight() - scaledHeight) / 2, 0.0F, 0.0F, scaledWidth, scaledHeight,
-                    scaledWidth, scaledHeight);
+                    (scope.getScaledWindowHeight() - scaledHeight) / 2, 0.0F, 0.0F, scaledWidth, scaledHeight);
         }
     }
 

src/main/java/org/saturnclient/saturnclient/SaturnClient.java

@@ -13,8 +13,7 @@ import org.saturnclient.saturnclient.config.ThemeManager;
 import org.saturnclient.saturnclient.cosmetics.Hats;
 import org.saturnclient.saturnclient.cosmetics.cloaks.Cloaks;
 import org.saturnclient.saturnclient.event.KeyInputHandler;
-import org.saturnclient.saturnclient.menus.SaturnMenu;
-import org.saturnclient.saturnclient.menus.SaturnTitleScreen;
+import org.saturnclient.ui2.screens.TitleMenu;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -38,11 +37,11 @@ public class SaturnClient implements ModInitializer {
         ThemeManager.load();
         ConfigManager.load();
         
-        ClientLifecycleEvents.CLIENT_STOPPING.register(_o -> {ConfigManager.save(); ThemeManager.save();});
+        ClientLifecycleEvents.CLIENT_STOPPING.register(_o -> ConfigManager.save());
         ScreenEvents.BEFORE_INIT.register((client, screen, scaledWidth, scaledHeight) -> {
             if (SaturnClientConfig.saturnTitleScreen.value && screen instanceof TitleScreen
-            && !(screen instanceof SaturnMenu)) {
-                client.setScreen(new SaturnTitleScreen());
+            && !(screen instanceof TitleMenu)) {
+                client.setScreen(new TitleMenu());
             }
         });
         

src/main/java/org/saturnclient/saturnclient/auth/Auth.java

@@ -117,16 +117,21 @@ public class Auth {
     private static void startPingThread() {
         pingThread = new Thread(() -> {
             try {
-                while (running) {
-                    Thread.sleep(25000); // 25 seconds
-                    if (running) {
-                        Network.write("ping");
+                while (running && !Thread.currentThread().isInterrupted()) {
+                    try {
+                        Thread.sleep(25000); // 25 seconds
+                        if (running) {
+                            Network.write("ping");
+                        }
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt(); // Restore interrupt status
+                        break; // Exit the loop on interruption
                     }
                 }
-            } catch (InterruptedException e) {
-                SaturnClient.LOGGER.warn("Ping thread interrupted", e);
             } catch (Exception e) {
-                SaturnClient.LOGGER.error("Error in ping thread", e);
+                if (!(e instanceof InterruptedException)) {
+                    SaturnClient.LOGGER.error("Error in ping thread", e);
+                }
             }
         });
 

src/main/java/org/saturnclient/saturnclient/event/KeyInputHandler.java

@@ -7,7 +7,7 @@ import net.minecraft.client.option.KeyBinding;
 import net.minecraft.client.util.InputUtil;
 
 // import org.saturnclient.modules.mods.FreeLook;
-import org.saturnclient.saturnclient.menus.ModMenu;
+import org.saturnclient.ui2.screens.ShiftMenu;
 // import org.saturnclient.saturnclient.menus.SaturnMenu;
 import org.lwjgl.glfw.GLFW;
 
@@ -46,7 +46,7 @@ public class KeyInputHandler {
         // Register the event handler for the main menu key
         ClientTickEvents.END_CLIENT_TICK.register(client -> {
             if (mainMenuKeyBinding.wasPressed()) {
-                client.setScreen(new ModMenu());
+                client.setScreen(new ShiftMenu());
             }
             // else if (freelookKeyBinding.wasPressed() && FreeLook.enabled.value && FreeLook.toggle.value) {
             //     FreeLook.isFreeLooking = !FreeLook.isFreeLooking;

src/main/java/org/saturnclient/ui2/Element.java

@@ -1,11 +1,20 @@
 package org.saturnclient.ui2;
 
+import java.util.function.Function;
+
+import org.saturnclient.ui2.anim.Animation;
+import org.saturnclient.ui2.anim.Curve;
+
 public class Element {
-    protected int x;
-    protected int y;
-    protected int width;
-    protected int height;
+    public int x;
+    public int y;
+    public int width;
+    public int height;
+    public float opacity = 1.0f;
     public boolean focused;
+    public Animation animation;
+    public float scale = 1.0f;
+    public Function<Double, Double> curve = Curve::easeInOutCubic;
 
     public void render(RenderScope renderScope, RenderContext ctx) {
     }
@@ -13,27 +22,52 @@ public class Element {
     public void click(int mouseX, int mouseY) {
     }
 
-    public final void dimensions(int width, int height) {
+    public final Element dimensions(int width, int height) {
         this.width = width;
         this.height = height;
+
+        return this;
     }
 
-    public final void position(int x, int y) {
+    public final Element position(int x, int y) {
         this.x = x;
         this.y = y;
+
+        return this;
+    }
+
+    public final Element centerHorizontal(int w, int h, int offsetX, int offsetY) {
+        this.x = (w - (int) (width * scale)) / 2 + offsetX;
+        this.y = offsetY;
+
+        return this;
     }
 
     public final Element center(int w, int h) {
-        this.x = (w - width) / 2;
-        this.y = (h - height) / 2;
-
+        this.centerOffset(w, h, 0, 0);
         return this;
     }
 
     public final Element centerOffset(int w, int h, int offsetX, int offsetY) {
-        this.x = (w - width) / 2 + offsetX;
-        this.y = (h - height) / 2 + offsetY;
+        this.x = (w - (int) (width * scale)) / 2 + offsetX;
+        this.y = (h - (int) (height * scale)) / 2 + offsetY;
 
         return this;
     }
+
+    public final Element animation(Animation animation) {
+        this.animation = animation;
+        return this;
+    }
+
+    public final Element animation(Animation animation, Function<Double, Double> curve) {
+        this.animation = animation;
+        this.curve = curve;
+        return this;
+    }
+
+    public Element scale(float scale) {
+        this.scale = scale;
+        return this;
+    }
 }

src/main/java/org/saturnclient/ui2/RenderContext.java

@@ -4,6 +4,7 @@ public class RenderContext {
     public int mouseX, mouseY;
     public int elementX, elementY;
     public int elementWidth, elementHeight;
+    public float elementScale;
 
     public RenderContext(int mouseX, int mouseY, Element e) {
         this.mouseX = mouseX;
@@ -12,12 +13,10 @@ public class RenderContext {
         this.elementY = e.y;
         this.elementWidth = e.width;
         this.elementHeight = e.height;
+        this.elementScale = e.scale;
     }
 
     public boolean isHovering() {
-        return mouseX >= elementX &&
-               mouseX <= elementX + elementWidth &&
-               mouseY >= elementY &&
-               mouseY <= elementY + elementHeight;
+        return Utils.isHovering(mouseX - elementX, mouseY - elementY, elementWidth, elementHeight, elementScale);
     }
 }

src/main/java/org/saturnclient/ui2/RenderScope.java

@@ -19,6 +19,7 @@ import net.minecraft.util.math.RotationAxis;
 public class RenderScope {
     public MatrixStack matrices;
     public VertexConsumerProvider.Immediate vertexConsumers;
+    private Function<Identifier, RenderLayer> renderLayers;
     private int opacity = 255 << 24;
 
     public RenderScope(MatrixStack matrices, VertexConsumerProvider.Immediate vertexConsumers) {
@@ -31,7 +32,14 @@ public class RenderScope {
     }
 
     public int getColor(int color) {
-        return opacity | (color & 0x00FFFFFF);
+        int originalAlpha = (color >>> 24) & 0xFF;
+        int newAlpha = (opacity >>> 24) & 0xFF;
+        int mixedAlpha = (originalAlpha * newAlpha) / 255;
+        return (mixedAlpha << 24) | (color & 0x00FFFFFF);
+    }    
+
+    public void setRenderLayer(Function<Identifier, RenderLayer> renderLayers) {
+        this.renderLayers = renderLayers;
     }
 
     public void drawRect(int x, int y, int width, int height, int color) {
@@ -68,9 +76,13 @@ public class RenderScope {
 
         Identifier font = bold ? Fonts.PANTON_BOLD : Fonts.PANTON;
 
+        matrices.push();
+        matrices.translate(x, y, 0);
+        matrices.scale(2.0f, 2.0f, 1.0f);
         TextRenderer textRenderer = SaturnClient.client.textRenderer;
-        textRenderer.draw(Fonts.setFont(text, font), (float) x, (float) y, color, false, this.matrices.peek().getPositionMatrix(),
+        textRenderer.draw(Fonts.setFont(text, font), 0, 0, color, false, this.matrices.peek().getPositionMatrix(),
                 this.vertexConsumers, TextLayerType.NORMAL, 0, 15728880);
+        matrices.pop();
     }
 
     public void drawRoundedCorner(int width, int height, int radius, int color) {
@@ -117,6 +129,7 @@ public class RenderScope {
     }
 
     public void drawRoundedRectangle(int x, int y, int width, int height, int radius, int color) {
+        radius = Math.min(radius, Math.min(width, height));
         int cornerWidth = width / 2;
         int cornerHeight = height / 2;
 
@@ -141,35 +154,42 @@ public class RenderScope {
         return SaturnClient.client.getWindow().getScaledWidth();
      }
   
-     public int getScaledWindowHeight() {
-        return SaturnClient.client.getWindow().getScaledHeight();
-     }
+    public int getScaledWindowHeight() {
+       return SaturnClient.client.getWindow().getScaledHeight();
+    }
+    public void drawTexture(Identifier sprite, int x, int y, float u, float v, int width, int height, int color) {
+       this.drawTexture(sprite, x, y, u, v, width, height, width, height, width, height, color);
+    }
 
-     public void drawTexture(Function<Identifier, RenderLayer> renderLayers, Identifier sprite, int x, int y, float u, float v, int width, int height, int textureWidth, int textureHeight, int color) {
-        this.drawTexture(renderLayers, sprite, x, y, u, v, width, height, width, height, textureWidth, textureHeight, color);
-     }
-  
-     public void drawTexture(Function<Identifier, RenderLayer> renderLayers, Identifier sprite, int x, int y, float u, float v, int width, int height, int textureWidth, int textureHeight) {
-        this.drawTexture(renderLayers, sprite, x, y, u, v, width, height, width, height, textureWidth, textureHeight);
-     }
-  
-     public void drawTexture(Function<Identifier, RenderLayer> renderLayers, Identifier sprite, int x, int y, float u, float v, int width, int height, int regionWith, int regionHeight, int textureWidth, int textureHeight) {
-        this.drawTexture(renderLayers, sprite, x, y, u, v, width, height, regionWith, regionHeight, textureWidth, textureHeight, -1);
-     }
-  
-     public void drawTexture(Function<Identifier, RenderLayer> renderLayers, Identifier sprite, int x, int y, float u, float v, int width, int height, int regionWidth, int regionHeight, int textureWidth, int textureHeight, int color) {
-        this.drawTexturedQuad(renderLayers, sprite, x, x + width, y, y + height, (u + 0.0F) / (float)textureWidth, (u + (float)regionWidth) / (float)textureWidth, (v + 0.0F) / (float)textureHeight, (v + (float)regionHeight) / (float)textureHeight, color);
-     }
-  
-     private void drawTexturedQuad(Function<Identifier, RenderLayer> renderLayers, Identifier sprite, int x1, int x2, int y1, int y2, float u1, float u2, float v1, float v2, int color) {
-        RenderSystem.setShaderTexture(0, sprite);
+    public void drawTexture(Identifier sprite, int x, int y, float u, float v, int width, int height) {
+       this.drawTexture(sprite, x, y, u, v, width, height, width, height, width, height);
+    }
 
-        RenderLayer renderLayer = (RenderLayer)renderLayers.apply(sprite);
-        Matrix4f matrix4f = this.matrices.peek().getPositionMatrix();
-        VertexConsumer vertexConsumer = this.vertexConsumers.getBuffer(renderLayer);
-        vertexConsumer.vertex(matrix4f, (float)x1, (float)y1, 0.0F).texture(u1, v1).color(color);
-        vertexConsumer.vertex(matrix4f, (float)x1, (float)y2, 0.0F).texture(u1, v2).color(color);
-        vertexConsumer.vertex(matrix4f, (float)x2, (float)y2, 0.0F).texture(u2, v2).color(color);
-        vertexConsumer.vertex(matrix4f, (float)x2, (float)y1, 0.0F).texture(u2, v1).color(color);
-     }
+    public void drawTexture(Identifier sprite, int x, int y, float u, float v, int width, int height, int regionWith, int regionHeight, int textureWidth, int textureHeight) {
+       this.drawTexture(sprite, x, y, u, v, width, height, regionWith, regionHeight, textureWidth, textureHeight, -1);
+    }
+
+    public void drawTexture(Identifier sprite, int x, int y, float u, float v, int width, int height, int regionWidth, int regionHeight, int textureWidth, int textureHeight, int color) {
+       this.drawTexturedQuad(sprite, x, x + width, y, y + height, (u + 0.0F) / (float)textureWidth, (u + (float)regionWidth) / (float)textureWidth, (v + 0.0F) / (float)textureHeight, (v + (float)regionHeight) / (float)textureHeight, color);
+    }
+
+    private void drawTexturedQuad(Identifier sprite, int x1, int x2, int y1, int y2, float u1, float u2, float v1, float v2, int color) {
+        x1 *= 4;
+        x2 *= 4;
+        y1 *= 4;
+        y2 *= 4;
+        color = getColor(color);
+
+        matrices.push();
+        matrices.scale(0.25f, 0.25f, 1.0f);
+       RenderSystem.setShaderTexture(0, sprite);
+       RenderLayer renderLayer = (RenderLayer)renderLayers.apply(sprite);
+       Matrix4f matrix4f = this.matrices.peek().getPositionMatrix();
+       VertexConsumer vertexConsumer = this.vertexConsumers.getBuffer(renderLayer);
+       vertexConsumer.vertex(matrix4f, (float)x1, (float)y1, 0.0F).texture(u1, v1).color(color);
+       vertexConsumer.vertex(matrix4f, (float)x1, (float)y2, 0.0F).texture(u1, v2).color(color);
+       vertexConsumer.vertex(matrix4f, (float)x2, (float)y2, 0.0F).texture(u2, v2).color(color);
+       vertexConsumer.vertex(matrix4f, (float)x2, (float)y1, 0.0F).texture(u2, v1).color(color);
+       matrices.pop();
+    }
 }

src/main/java/org/saturnclient/ui2/SaturnScreen.java

@@ -5,35 +5,84 @@ import java.util.List;
 
 import org.saturnclient.saturnclient.config.ThemeManager;
 import org.saturnclient.saturnclient.mixin.DrawContextAccessor;
+import org.saturnclient.ui2.anim.Animation;
 
+import net.minecraft.client.gl.PostEffectProcessor;
+import net.minecraft.client.gui.CubeMapRenderer;
 import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.gui.RotatingCubeMapRenderer;
 import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.render.DefaultFramebufferSet;
+import net.minecraft.client.util.Pool;
 import net.minecraft.text.Text;
+import net.minecraft.util.Identifier;
 
-public class SaturnScreen extends Screen {
+public abstract class SaturnScreen extends Screen {
+    private final Pool pool = new Pool(3);
     protected List<Element> elements = new ArrayList<>();
+    public int blurDuration = 700;
+    public float blurProgress = 0.0f;
+    public int backgroundBlur = 10;
+
+    protected static final CubeMapRenderer PANORAMA_RENDERER = new CubeMapRenderer(
+            Identifier.of("saturnclient", "textures/gui/title/background/panorama"));
+
+    public static final RotatingCubeMapRenderer ROTATING_PANORAMA_RENDERER;
+
+    static {
+        ROTATING_PANORAMA_RENDERER = new RotatingCubeMapRenderer(PANORAMA_RENDERER);
+    }
 
     public SaturnScreen(String title) {
         super(Text.literal(title));
-        ThemeManager.load();
     }
 
     public void draw(Element element) {
         synchronized (elements) {
             elements.add(element);
         }
+        
+        if (element.animation != null) {
+            element.animation.init(element);
+
+            Animation.execute((Float progress) -> {
+                element.animation.tick(progress, element);
+            }, element.animation.duration);
+        }
     }
 
     @Override
     protected void init() {
+        width *= 2;
+        height *= 2;
         ui(); // abstraction to render the saturn ui and also render extra stuff here
+        ThemeManager.load();
+
+        Animation.execute((Float progress) -> {
+            blurProgress = progress;
+        }, blurDuration);
     }
 
-    public void ui() {
-    }
+    public abstract void ui();
 
+    @SuppressWarnings("deprecation")
     @Override
     public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+        mouseX *= 2;
+        mouseY *= 2;
+
+        if (client.world == null && client.getCurrentServerEntry() == null) {
+            ROTATING_PANORAMA_RENDERER.render(context, this.width, this.height, 1.0F, delta);
+        }
+
+        PostEffectProcessor postEffectProcessor = this.client.getShaderLoader().loadPostEffect(
+                    Identifier.ofVanilla("blur"),
+                    DefaultFramebufferSet.MAIN_ONLY);
+            if (postEffectProcessor != null) {
+                postEffectProcessor.setUniforms("Radius", backgroundBlur * blurProgress);
+                postEffectProcessor.render(this.client.getFramebuffer(), this.pool);
+            }
+
         // We are using a Abstracted RenderScope because older minecraft versions don't
         // use DrawContext
         RenderScope renderScope = new RenderScope(context.getMatrices(),
@@ -41,11 +90,16 @@ public class SaturnScreen extends Screen {
 
         renderScope.matrices.push();
 
+        renderScope.matrices.scale(0.5f, 0.5f, 0.5f);
+
         for (Element element : elements) {
             renderScope.matrices.push();
+            renderScope.setOpacity(element.opacity);
             renderScope.matrices.translate(element.x, element.y, 0);
+            renderScope.matrices.scale(element.scale, element.scale, 1.0f);
             element.render(renderScope, new RenderContext(mouseX, mouseY, element));
             renderScope.matrices.pop();
+            renderScope.setRenderLayer(null);
         }
 
         renderScope.matrices.pop();
@@ -53,6 +107,8 @@ public class SaturnScreen extends Screen {
 
     @Override
     public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        mouseX *= 2;
+        mouseY *= 2;
         if (button == 0) {
             for (Element element : new ArrayList<>(elements)) {
                 element.focused = false;
@@ -60,7 +116,7 @@ public class SaturnScreen extends Screen {
                 int adjustedMouseX = (int) mouseX - element.x;
                 int adjustedMouseY = (int) mouseY - element.y;
 
-                if (Utils.isHovering(adjustedMouseX, adjustedMouseY, element.width, element.height)) {
+                if (Utils.isHovering(adjustedMouseX, adjustedMouseY, element.width, element.height, element.scale)) {
                     element.focused = true;
                     element.click(adjustedMouseX, adjustedMouseY);
                 }

src/main/java/org/saturnclient/ui2/Utils.java

@@ -1,10 +1,10 @@
 package org.saturnclient.ui2;
 
 public class Utils {
-    public static boolean isHovering(int mouseX, int mouseY, int elementWidth, int elementHeight) {
+    public static boolean isHovering(int mouseX, int mouseY, int elementWidth, int elementHeight, float elementScale) {
         return mouseX >= 0 &&
-               mouseX <= elementWidth &&
+               mouseX <= (elementWidth * elementScale) &&
                mouseY >= 0 &&
-               mouseY <= elementHeight;
+               mouseY <= (elementHeight * elementScale);
     }
 }

src/main/java/org/saturnclient/ui2/anim/Animation.java

@@ -0,0 +1,53 @@
+package org.saturnclient.ui2.anim;
+
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import org.saturnclient.ui2.Element;
+
+public abstract class Animation {
+    public int duration;
+
+    Animation(int duration) {
+        this.duration = duration;
+    }
+
+    public abstract void tick(float progress, Element element);
+    public abstract void init(Element element);
+
+    public static void execute(Consumer<Float> tick, int duration) {
+        new Thread(() -> {
+            long startTime = System.currentTimeMillis();
+
+            Function<Double, Double> curveFunction = Curve::easeInOutCubic;
+            float progress = 0.0f;
+            double incremental = (1000 - duration) / 10000.0;
+
+            System.out.println("Starting animation...");
+
+            for (int i = 0; i <= 100; i++) {
+                float newProgress = (float) (double) curveFunction.apply(i / 100.0);
+
+                while (Math.abs(newProgress - progress) > 1e-6) {
+                    if (progress < newProgress) {
+                        progress += incremental;
+                        if (progress > newProgress) progress = newProgress;
+                    } else {
+                        progress -= incremental;
+                        if (progress < newProgress) progress = newProgress;
+                    }
+
+                    tick.accept(newProgress);
+
+                    try {
+                        Thread.sleep(duration / 100);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }            
+                }
+            }
+
+            System.out.println("Animation complete. " + (System.currentTimeMillis() - startTime) + "MS");
+        }).start();
+    }
+}

src/main/java/org/saturnclient/ui2/anim/Curve.java

@@ -0,0 +1,26 @@
+package org.saturnclient.ui2.anim;
+
+public class Curve {
+    public static double easeOutCubic(double x) {
+        return 1 - Math.pow(1 - x, 3);
+    }
+
+    public static double easeInOutCubic(double x) {
+        return (x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2);
+    }
+
+    public static double easeInOutCubicReverse(double x) {
+        return -(x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2);
+    }
+
+    public static double easeInOutBack(double x) {
+        double c1 = 1.70158;
+        double c2 = c1 * 1.525;
+
+        if (x < 0.5) {
+            return (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2;
+        } else {
+            return (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (2 * x - 2) + c2) + 2) / 2;
+        }
+    }
+}

src/main/java/org/saturnclient/ui2/anim/Fade.java

@@ -0,0 +1,22 @@
+package org.saturnclient.ui2.anim;
+
+import org.saturnclient.ui2.Element;
+
+public class Fade extends Animation {
+    float targetOpacity;
+
+    public Fade(int duration) {
+        super(duration);
+    }
+
+    @Override
+    public void tick(float progress, Element element) {
+        element.opacity = targetOpacity * progress;
+    }
+
+    @Override
+    public void init(Element element) {
+        targetOpacity = element.opacity;
+        element.opacity = 0;
+    }
+}

src/main/java/org/saturnclient/ui2/anim/SlideY.java

@@ -0,0 +1,38 @@
+package org.saturnclient.ui2.anim;
+
+import org.saturnclient.ui2.Element;
+
+public class SlideY extends Animation {
+    int offset = 20;
+    int maxOffset = 20;
+    int elementY;
+
+    public SlideY(int duration) {
+        super(duration);
+    }
+
+    public SlideY(int duration, int offset) {
+        super(duration);
+
+        this.offset = offset;
+        this.maxOffset = offset;
+    }
+
+    public SlideY(int duration, int offset, int maxOffset) {
+        super(duration);
+
+        this.offset = offset;
+        this.maxOffset = offset;
+    }
+    
+    @Override
+    public void tick(float progress, Element element) {
+        element.y = elementY + (int) (offset * progress);
+    }
+
+    @Override
+    public void init(Element element) {
+        element.y -= offset;
+        elementY = element.y;
+    }
+}

src/main/java/org/saturnclient/ui2/elements/Button.java

@@ -13,6 +13,7 @@ public class Button extends Element {
     private static ThemeManager theme = new ThemeManager("Button", "hovering");
     private static Property<Integer> bgColor = theme.property("bg-color", new Property<Integer>(0xFF000000));
     private static Property<Integer> fgColor = theme.property("fg-color", new Property<Integer>(0xFFFFFFFF));
+    private static Property<Integer> cornerRadius = theme.property("corner-radius", new Property<Integer>(10));
     private static Property<Boolean> bold = theme.property("fg-bold", new Property<Boolean>(false));
 
     static {
@@ -27,7 +28,7 @@ public class Button extends Element {
         this.text = text;
         this.font = Fonts.getFont(bold.value);
         this.onClick = onClick;
-        this.dimensions(Fonts.getWidth(text, font)+ 25 , Fonts.getHeight() + 10);
+        this.dimensions(Fonts.getWidth(text, font) + 50, Fonts.getHeight() + 20);
     }
 
     @Override
@@ -37,9 +38,9 @@ public class Button extends Element {
         } else {
             theme.setState(null);
         }
-        renderScope.drawRoundedRectangle(0, 0, width, height, 10, bgColor.value);
+        renderScope.drawRoundedRectangle(0, 0, width, height, cornerRadius.value, bgColor.value);
 
-        renderScope.drawText(text, width / 2 - Fonts.getWidth(text, font) / 2, height / 2 - Fonts.getHeight() / 2, bold.value, fgColor.value);
+        renderScope.drawText(text, (width - Fonts.getWidth(text, font)) / 2, (height - Fonts.getHeight()) / 2, bold.value, fgColor.value);
     }
 
     @Override

src/main/java/org/saturnclient/ui2/elements/ClickableTexture.java

@@ -0,0 +1,42 @@
+package org.saturnclient.ui2.elements;
+
+import org.saturnclient.saturnclient.config.Property;
+import org.saturnclient.saturnclient.config.ThemeManager;
+import org.saturnclient.ui2.Element;
+import org.saturnclient.ui2.RenderContext;
+import org.saturnclient.ui2.RenderScope;
+
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.util.Identifier;
+
+public class ClickableTexture extends Element {
+    private static ThemeManager theme = new ThemeManager("ClickableTexture", "hovering");
+    private static Property<Integer> fgColor = theme.property("fg-color", new Property<Integer>(0xFFFFFFFF));
+
+    Identifier sprite;
+    private Runnable onClick;
+
+    public ClickableTexture(Identifier sprite, Runnable onClick) {
+        this.sprite = sprite;
+        this.onClick = onClick;
+    }
+    
+    @Override
+    public void render(RenderScope renderScope, RenderContext ctx) {
+        if (ctx.isHovering()) {
+            theme.setState("hovering");
+        } else {
+            theme.setState(null);
+        }
+        
+        renderScope.setRenderLayer(RenderLayer::getGuiTextured);
+        renderScope.drawTexture(sprite, 0, 0, 0, 0, width, height, fgColor.value);
+    }
+
+    @Override
+    public void click(int mouseX, int mouseY) {
+        if (onClick != null) {
+            onClick.run();
+        }
+    }
+}

src/main/java/org/saturnclient/ui2/elements/ImageTexture.java

@@ -0,0 +1,22 @@
+package org.saturnclient.ui2.elements;
+
+import org.saturnclient.ui2.Element;
+import org.saturnclient.ui2.RenderContext;
+import org.saturnclient.ui2.RenderScope;
+
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.util.Identifier;
+
+public class ImageTexture extends Element {
+    Identifier sprite;
+
+    public ImageTexture(Identifier sprite) {
+        this.sprite = sprite;
+    }
+
+    @Override
+    public void render(RenderScope renderScope, RenderContext ctx) {
+        renderScope.setRenderLayer(RenderLayer::getGuiTextured);
+        renderScope.drawTexture(sprite, 0, 0, 0, 0, width, height);
+    }
+}

src/main/java/org/saturnclient/ui2/elements/Text.java

@@ -1,10 +1,15 @@
 package org.saturnclient.ui2.elements;
 
+import org.saturnclient.saturnclient.config.Property;
+import org.saturnclient.saturnclient.config.ThemeManager;
 import org.saturnclient.ui2.Element;
 import org.saturnclient.ui2.RenderContext;
 import org.saturnclient.ui2.RenderScope;
 
 public class Text extends Element {
+    private static ThemeManager theme = new ThemeManager("Text");
+    private static Property<Integer> fgColor = theme.property("fg-color", new Property<Integer>(0xFFFFFFFF));
+
     private String text;
 
     public Text(String text) {
@@ -13,6 +18,6 @@ public class Text extends Element {
 
     @Override
     public void render(RenderScope renderScope, RenderContext ctx) {
-        renderScope.drawText(this.text, this.x, this.y, false, 0xFFFFFFFF);
+        renderScope.drawText(this.text, this.x, this.y, false, fgColor.value);
     }
 }

src/main/java/org/saturnclient/ui2/elements/TextureButton.java

@@ -0,0 +1,56 @@
+package org.saturnclient.ui2.elements;
+
+import org.saturnclient.saturnclient.config.Property;
+import org.saturnclient.saturnclient.config.ThemeManager;
+import org.saturnclient.ui2.Element;
+import org.saturnclient.ui2.RenderContext;
+import org.saturnclient.ui2.RenderScope;
+
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.util.Identifier;
+
+public class TextureButton extends Element {
+    private static ThemeManager theme = new ThemeManager("TextureButton", "hovering");
+    private static Property<Integer> bgColor = theme.property("bg-color", new Property<Integer>(0xFF000000));
+    private static Property<Integer> fgColor = theme.property("fg-color", new Property<Integer>(0xFFFFFFFF));
+    private static Property<Integer> padding = theme.property("padding", new Property<Integer>(14));
+    private static Property<Integer> cornerRadius = theme.property("corner-radius", new Property<Integer>(10));
+
+
+    static {
+        theme.propertyStateDefault("hovering", "fg-color", 0xFFFF0000);
+    }
+
+    Identifier sprite;
+    private Runnable onClick;
+
+    public TextureButton(Identifier sprite, Runnable onClick) {
+        this.sprite = sprite;
+        this.onClick = onClick;
+    }
+    
+    @Override
+    public void render(RenderScope renderScope, RenderContext ctx) {
+        if (ctx.isHovering()) {
+            theme.setState("hovering");
+        } else {
+            theme.setState(null);
+        }
+
+        renderScope.drawRoundedRectangle(0, 0, width, height, cornerRadius.value, bgColor.value);
+        
+        renderScope.setRenderLayer(RenderLayer::getGuiTextured);
+
+        int texWidth = width - padding.value;
+        int texHeight = height - padding.value;
+        
+        renderScope.drawTexture(sprite, padding.value / 2, padding.value / 2, 0, 0, texWidth, texHeight, fgColor.value);
+    }
+
+    @Override
+    public void click(int mouseX, int mouseY) {
+        if (onClick != null) {
+            onClick.run();
+        }
+    }
+}

src/main/java/org/saturnclient/ui2/resources/Fonts.java

@@ -22,12 +22,21 @@ public class Fonts {
             Style.EMPTY.withFont(font));
     }
 
+    // public static int getWidth(String text, Identifier font) {
+    //     return SaturnClient.client.textRenderer.getWidth(Text.literal(text).setStyle(
+    //         Style.EMPTY.withFont(font)));
+    // }
+
+    // public static int getHeight() {
+    //     return SaturnClient.client.textRenderer.fontHeight;
+    // }
+
     public static int getWidth(String text, Identifier font) {
         return SaturnClient.client.textRenderer.getWidth(Text.literal(text).setStyle(
-            Style.EMPTY.withFont(font)));
+            Style.EMPTY.withFont(font))) * 2;
     }
 
     public static int getHeight() {
-        return SaturnClient.client.textRenderer.fontHeight;
+        return SaturnClient.client.textRenderer.fontHeight * 2;
     }
 }

src/main/java/org/saturnclient/ui2/screens/ShiftMenu.java

@@ -1,8 +1,18 @@
 package org.saturnclient.ui2.screens;
 
 import org.saturnclient.saturnclient.SaturnClient;
+import org.saturnclient.saturnclient.SaturnClientConfig;
+import org.saturnclient.saturnclient.menus.CloaksMenu;
+import org.saturnclient.saturnclient.menus.HudEditor;
+import org.saturnclient.saturnclient.menus.ModMenu;
+import org.saturnclient.ui.Textures;
+import org.saturnclient.ui2.Element;
 import org.saturnclient.ui2.SaturnScreen;
 import org.saturnclient.ui2.elements.Button;
+import org.saturnclient.ui2.elements.ImageTexture;
+import org.saturnclient.ui2.elements.TextureButton;
+import org.saturnclient.ui2.anim.Fade;
+import org.saturnclient.ui2.anim.SlideY;
 
 public class ShiftMenu extends SaturnScreen {
     public ShiftMenu() {
@@ -11,8 +21,21 @@ public class ShiftMenu extends SaturnScreen {
 
     @Override
     public void ui() {
-        draw(new Button("Click Me!", () -> {
-            SaturnClient.LOGGER.info("Clicked!");
-        }).center(width, height));
+        draw(new ImageTexture(Textures.LOGO_TEXT).dimensions(98, 16).centerOffset(width, height, 0, -36).animation(new Fade(700)));
+        draw(new ImageTexture(SaturnClientConfig.getLogo()).dimensions(98, 98).centerOffset(width, height, 0, -80).animation(new SlideY(700, -40)));
+
+        Element button = new Button("Settings", () -> {
+            SaturnClient.client.setScreen(new ModMenu());
+        }).center(width, height);
+
+        draw(button);
+
+        draw(new TextureButton(Textures.COSMETICS, () -> {
+            client.setScreen(new CloaksMenu());
+        }).dimensions(button.height, button.height).centerOffset(width, height, (button.width / 2) + (button.height / 2) + 4, 0));
+
+        draw(new TextureButton(Textures.HUD_ICON, () -> {
+            client.setScreen(new HudEditor());
+        }).dimensions(button.height, button.height).centerOffset(width, height, -((button.width / 2) + (button.height / 2) + 4), 0));
     }
 }

src/main/java/org/saturnclient/ui2/screens/TitleMenu.java

@@ -0,0 +1,63 @@
+package org.saturnclient.ui2.screens;
+
+import org.saturnclient.saturnclient.SaturnClient;
+import org.saturnclient.saturnclient.SaturnClientConfig;
+import org.saturnclient.saturnclient.menus.CloaksMenu;
+import org.saturnclient.saturnclient.menus.HudEditor;
+import org.saturnclient.saturnclient.menus.ModMenu;
+import org.saturnclient.ui.Textures;
+import org.saturnclient.ui2.SaturnScreen;
+import org.saturnclient.ui2.anim.Fade;
+import org.saturnclient.ui2.anim.SlideY;
+import org.saturnclient.ui2.elements.Button;
+import org.saturnclient.ui2.elements.ImageTexture;
+import org.saturnclient.ui2.elements.TextureButton;
+import org.saturnclient.ui2.resources.Fonts;
+
+import net.minecraft.client.gui.screen.multiplayer.MultiplayerScreen;
+import net.minecraft.client.gui.screen.option.OptionsScreen;
+import net.minecraft.client.gui.screen.world.SelectWorldScreen;
+
+public class TitleMenu extends SaturnScreen {
+    public TitleMenu() {
+        super("Tile Menu");
+    }
+
+    @Override
+    public void ui() {
+        backgroundBlur = 0;
+
+        draw(new ImageTexture(Textures.LOGO_TEXT).dimensions(98, 16).centerOffset(width, height, 0, -40).animation(new Fade(700)));
+        draw(new ImageTexture(SaturnClientConfig.getLogo()).dimensions(98, 98).centerOffset(width, height, 0, -82).animation(new SlideY(700, -40)));
+
+        draw(new Button("SINGLEPLAYER", () -> {
+            client.setScreen(new SelectWorldScreen(new TitleMenu()));
+        }).scale(0.69f).dimensions(420, 52).centerOffset(width, height, 0, 0));
+
+        draw(new Button("MULTIPLAYER", () -> {
+            client.setScreen(new MultiplayerScreen(new TitleMenu()));
+        }).scale(0.69f).dimensions(420, 52).centerOffset(width, height, 0, 40));
+
+        draw(new Button("OPTIONS", () -> {
+            client.setScreen(new OptionsScreen(new TitleMenu(), SaturnClient.client.options));
+        }).scale(0.69f).dimensions(206, 52).centerOffset(width, height, -73, 80));
+
+        draw(new Button("QUIT", () -> {
+            client.scheduleStop();
+        }).scale(0.69f).dimensions(206, 52).centerOffset(width, height, 73, 80));
+
+        int s = Fonts.getHeight() + 20;
+
+        draw(new TextureButton(Textures.HUD_ICON, () -> {
+            client.setScreen(new HudEditor());
+        }).dimensions(s, s).centerHorizontal(width, height, -(s + 2), 8).animation(new SlideY(700, s + 8)));
+
+        draw(new TextureButton(Textures.SETTINGS, () -> {
+            SaturnClient.client.setScreen(new ModMenu());
+        }).dimensions(s, s).centerHorizontal(width, height, 0, 8).animation(new SlideY(700, s + 8)));
+
+        draw(new TextureButton(Textures.CLOAK, () -> {
+            client.setScreen(new CloaksMenu());
+        }).dimensions(s, s).centerHorizontal(width, height, s + 2, 8).animation(new SlideY(700, s + 8)));
+    }
+}