Merge branch 'feature/renderer'

Author: Avanatiker

common/src/main/java/com/lambda/mixin/render/ChatScreenMixin.java

@@ -1,9 +1,12 @@
 package com.lambda.mixin.render;
 
+import com.lambda.Lambda;
 import com.lambda.command.CommandManager;
 import com.lambda.graphics.renderer.gui.font.FontRenderer;
 import com.lambda.graphics.renderer.gui.font.LambdaEmoji;
 import com.lambda.graphics.renderer.gui.font.glyph.GlyphInfo;
+import com.lambda.module.modules.client.LambdaMoji;
+import com.lambda.util.math.Vec2d;
 import kotlin.Pair;
 import kotlin.ranges.IntRange;
 import net.minecraft.client.gui.screen.ChatScreen;
@@ -13,16 +16,22 @@
 import org.spongepowered.asm.mixin.injection.ModifyArg;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 @Mixin(ChatScreen.class)
 public abstract class ChatScreenMixin {
     @ModifyArg(method = "sendMessage", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayNetworkHandler;sendChatMessage(Ljava/lang/String;)V"), index = 0)
     private String modifyChatText(String chatText) {
+        if (LambdaMoji.INSTANCE.isDisabled()) return chatText;
+
         List<Pair<GlyphInfo, IntRange>> emojis = FontRenderer.Companion.parseEmojis(chatText, LambdaEmoji.Twemoji);
         Collections.reverse(emojis);
 
+        List<String> pushEmojis = new ArrayList<>();
+        List<Vec2d> pushPositions = new ArrayList<>();
+
         for (Pair<GlyphInfo, IntRange> emoji : emojis) {
             String emojiString = chatText.substring(emoji.getSecond().getStart() + 1, emoji.getSecond().getEndInclusive());
             if (LambdaEmoji.Twemoji.get(emojiString) == null)
@@ -33,10 +42,20 @@ private String modifyChatText(String chatText) {
             // and render it after the text
             chatText = chatText.substring(0, emoji.getSecond().getStart()) + " " + chatText.substring(emoji.getSecond().getEndInclusive() + 1);
 
-            // TODO: Build a renderer for the emojis
-            // TODO: Render the emojis at their correct position
+            // We cannot retain the position in the future, but we can
+            // assume that every time you send a message the height of
+            // the position will change by the height of the glyph
+            // The positions are from the top left corner of the screen
+            int x = Lambda.getMc().textRenderer.getWidth(chatText.substring(0, emoji.getSecond().getStart()));
+            int y = Lambda.getMc().textRenderer.fontHeight;
+
+            pushEmojis.add(String.format(":%s:", emojiString));
+            pushPositions.add(new Vec2d(x, y));
         }
 
+        // Not optimal because it has to parse the emoji again but who cares
+        LambdaMoji.INSTANCE.add(pushEmojis, pushPositions);
+
         return chatText;
     }
 

common/src/main/kotlin/com/lambda/Lambda.kt

@@ -42,5 +42,9 @@ object Lambda {
         .registerTypeAdapter(GameProfile::class.java, GameProfileSerializer)
         .create()
 
-    fun initialize() = Loader.initialize()
+    fun initialize() {
+        recordRenderCall {
+            Loader.initialize()
+        }
+    }
 }

common/src/main/kotlin/com/lambda/config/groups/BuildConfig.kt

@@ -11,4 +11,5 @@ interface BuildConfig {
     val breaksPerTick: Int
     val rotateForBreak: Boolean
     val rotateForPlace: Boolean
+    val pingTimeout: Boolean
 }

common/src/main/kotlin/com/lambda/config/groups/BuildSettings.kt

@@ -7,7 +7,7 @@ class BuildSettings(
     vis: () -> Boolean = { true }
 ) : BuildConfig {
     enum class Page {
-        BREAK, PLACE, PATHING
+        BREAK, PLACE, GENERAL
     }
 
     private val page by c.setting("Build Page", Page.BREAK, "Current page", vis)
@@ -17,11 +17,13 @@ class BuildSettings(
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() && page == Page.BREAK }
     override val breaksPerTick by c.setting("Instant Breaks Per Tick", 10, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.BREAK }
     override val rotateForBreak by c.setting("Rotate For Break", false, "Rotate towards block while breaking") { vis() && page == Page.BREAK }
+    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.BREAK }
 
     override val placeCooldown by c.setting("Place Cooldown", 0, 0..1000, 1, "Delay between placing blocks", " ms") { vis() && page == Page.PLACE }
-    override val placeConfirmation by c.setting("Place Confirmation", false, "Wait for block placement confirmation") { vis() && page == Page.PLACE }
-    override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.PLACE }
+    override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.PLACE }
+
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.PLACE }
 
-    override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.PATHING }
+    override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.GENERAL }
+    override val pingTimeout by c.setting("Ping Timeout", true, "Timeout on high ping") { vis() && page == Page.GENERAL }
 }

common/src/main/kotlin/com/lambda/core/Loader.kt

@@ -28,6 +28,8 @@ object Loader {
         HudGuiConfigurable,
         FriendRegistry,
         SoundRegistry,
+        TimerManager,
+        PingManager,
         ContainerManager
     )
 

common/src/main/kotlin/com/lambda/core/PingManager.kt

@@ -0,0 +1,29 @@
+package com.lambda.core
+
+import com.lambda.event.events.PacketEvent
+import com.lambda.event.events.TickEvent
+import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.util.collections.LimitedOrderedSet
+import net.minecraft.network.packet.c2s.query.QueryPingC2SPacket
+import net.minecraft.network.packet.s2c.query.PingResultS2CPacket
+import net.minecraft.util.Util
+
+object PingManager : Loadable {
+    private val pings: LimitedOrderedSet<Long> = LimitedOrderedSet(100)
+    private const val INTERVAL = 1
+
+    val lastPing: Long
+        get() = pings.lastOrNull() ?: 0
+
+    init {
+        listener<TickEvent.Pre> {
+            connection.sendPacket(QueryPingC2SPacket(Util.getMeasuringTimeMs()))
+        }
+
+        listener<PacketEvent.Receive.Pre> { event ->
+            if (event.packet !is PingResultS2CPacket) return@listener
+
+            pings.add(Util.getMeasuringTimeMs() - event.packet.startTime)
+        }
+    }
+}

common/src/main/kotlin/com/lambda/core/TimerManager.kt

@@ -5,7 +5,7 @@ import com.lambda.event.events.ClientEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.UnsafeListener.Companion.unsafeListener
 
-object TimerManager {
+object TimerManager : Loadable {
     @JvmStatic
     var tickLength = 50f; private set
 

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

@@ -4,39 +4,19 @@ import com.lambda.Lambda.mc
 import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
-import com.lambda.graphics.renderer.esp.DirectionMask
-import com.lambda.graphics.renderer.esp.EntityEspRenderer
+import com.lambda.graphics.renderer.esp.global.BlockESPRenderer
+import com.lambda.graphics.renderer.esp.global.EntityESPRenderer
 import com.lambda.util.math.Vec2d
-import net.minecraft.entity.Entity
-import java.awt.Color
 
 abstract class RenderEvent : Event {
     class World : RenderEvent()
 
+    class BlockESP : RenderEvent() {
+        val renderer = BlockESPRenderer
+    }
+
     class EntityESP : RenderEvent() {
-        fun build(
-            entity: Entity,
-            filledColor: Color,
-            outlineColor: Color,
-            sides: Int = DirectionMask.ALL,
-            outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR
-        ) {
-            buildFilled(entity, filledColor, sides)
-            buildOutline(entity, outlineColor, sides, outlineMode)
-        }
-
-        fun buildFilled(
-            entity: Entity,
-            color: Color,
-            sides: Int = DirectionMask.ALL
-        ) = EntityEspRenderer.buildFilled(entity, color, sides)
-
-        fun buildOutline(
-            entity: Entity,
-            color: Color,
-            sides: Int = DirectionMask.ALL,
-            outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR
-        ) = EntityEspRenderer.buildOutline(entity, color, sides, outlineMode)
+        val renderer = EntityESPRenderer
     }
 
     abstract class GUI(val scale: Double) : RenderEvent() {

common/src/main/kotlin/com/lambda/graphics/RenderMain.kt

@@ -7,7 +7,8 @@ import com.lambda.graphics.gl.GlStateUtils.setupGL
 import com.lambda.graphics.gl.Matrices
 import com.lambda.graphics.gl.Matrices.resetMatrix
 import com.lambda.graphics.gl.Matrices.translate
-import com.lambda.graphics.renderer.esp.EntityEspRenderer
+import com.lambda.graphics.renderer.esp.global.BlockESPRenderer
+import com.lambda.graphics.renderer.esp.global.EntityESPRenderer
 import com.lambda.module.modules.client.GuiSettings
 import com.lambda.util.math.Vec2d
 import com.mojang.blaze3d.systems.RenderSystem.getProjectionMatrix
@@ -41,7 +42,8 @@ object RenderMain {
 
         setupGL {
             RenderEvent.World().post()
-            EntityEspRenderer.render()
+            BlockESPRenderer.render()
+            EntityESPRenderer.render()
         }
     }
 

common/src/main/kotlin/com/lambda/graphics/buffer/FrameBuffer.kt

@@ -0,0 +1,127 @@
+package com.lambda.graphics.buffer
+import com.lambda.Lambda.mc
+import com.lambda.graphics.RenderMain
+import com.lambda.graphics.buffer.vao.VAO
+import com.lambda.graphics.buffer.vao.vertex.VertexAttrib
+import com.lambda.graphics.buffer.vao.vertex.VertexMode
+import com.lambda.graphics.gl.GlStateUtils.withBlendFunc
+import com.lambda.graphics.shader.Shader
+import com.lambda.graphics.texture.TextureUtils.bindTexture
+import com.lambda.graphics.texture.TextureUtils.setupTexture
+import com.lambda.util.math.Vec2d
+import org.lwjgl.opengl.GL30.*
+import java.nio.IntBuffer
+
+class FrameBuffer(private val depth: Boolean = false) {
+    private val fbo = glGenFramebuffers()
+
+    private val colorAttachment = glGenTextures()
+    private val depthAttachment by lazy(::glGenTextures)
+
+    private val clearMask = if (!depth) GL_COLOR_BUFFER_BIT
+    else GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT
+
+    private var width = 0
+    private var height = 0
+
+    fun write(block: () -> Unit): FrameBuffer {
+        val prev = lastFrameBuffer ?: mc.framebuffer.fbo
+
+        glBindFramebuffer(GL_FRAMEBUFFER, fbo)
+        lastFrameBuffer = fbo
+
+        update()
+        withBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA, block)
+
+        lastFrameBuffer = prev
+        glBindFramebuffer(GL_FRAMEBUFFER, prev)
+        return this
+    }
+
+    fun read(
+        shader: Shader,
+        pos1: Vec2d = Vec2d.ZERO,
+        pos2: Vec2d = RenderMain.screenSize,
+        shaderBlock: (Shader) -> Unit = {}
+    ): FrameBuffer {
+        bindColorTexture()
+
+        shader.use()
+        shaderBlock(shader)
+
+        vao.use {
+            grow(4)
+
+            val uv1 = pos1 / RenderMain.screenSize
+            val uv2 = pos2 / RenderMain.screenSize
+
+            putQuad(
+                vec2(pos1.x, pos1.y).vec2(uv1.x, 1.0 - uv1.y).end(),
+                vec2(pos1.x, pos2.y).vec2(uv1.x, 1.0 - uv2.y).end(),
+                vec2(pos2.x, pos2.y).vec2(uv2.x, 1.0 - uv2.y).end(),
+                vec2(pos2.x, pos1.y).vec2(uv2.x, 1.0 - uv1.y).end()
+            )
+        }
+
+        withBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA) {
+            vao.upload()
+            vao.render()
+            vao.clear()
+        }
+
+        return this
+    }
+
+    fun bindColorTexture(slot: Int = 0): FrameBuffer {
+        bindTexture(colorAttachment, slot)
+        return this
+    }
+
+    fun bindDepthTexture(slot: Int = 0): FrameBuffer {
+        check(depth) {
+            "Cannot bind depth texture of a non-depth framebuffer"
+        }
+
+        bindTexture(depthAttachment, slot)
+        return this
+    }
+
+    private fun update() {
+        val widthIn = mc.window.framebufferWidth
+        val heightIn = mc.window.framebufferHeight
+
+        if (width != widthIn || height != heightIn) {
+            width = widthIn
+            height = heightIn
+
+            setupBufferTexture(colorAttachment)
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, null as IntBuffer?)
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorAttachment, 0)
+
+            if (depth) {
+                setupBufferTexture(depthAttachment)
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32F, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, null as IntBuffer?)
+                glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthAttachment, 0)
+            }
+
+            glClearColor(0f, 0f, 0f, 0f)
+            glClearDepth(1.0)
+        }
+
+        glClear(clearMask)
+    }
+
+    private fun setupBufferTexture(id: Int) {
+        bindTexture(id)
+        setupTexture(GL_NEAREST, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+    }
+
+    companion object {
+        private val vao = VAO(VertexMode.TRIANGLES, VertexAttrib.Group.POS_UV)
+        private var lastFrameBuffer: Int? = null
+    }
+}