Framebuffer optimization & misc

Author: bladekt

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

@@ -12,11 +12,14 @@ import com.lambda.util.math.Vec2d
 import org.lwjgl.opengl.GL30.*
 import java.nio.IntBuffer
 
-class FrameBuffer {
+class FrameBuffer(private val depth: Boolean = false) {
     private val fbo = glGenFramebuffers()
 
     private val colorAttachment = glGenTextures()
-    private val depthAttachment = 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
@@ -75,6 +78,10 @@ class FrameBuffer {
     }
 
     fun bindDepthTexture(slot: Int = 0): FrameBuffer {
+        check(depth) {
+            "Cannot bind depth texture of a non-depth framebuffer"
+        }
+
         bindTexture(depthAttachment, slot)
         return this
     }
@@ -91,12 +98,17 @@ class FrameBuffer {
             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)
 
-            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)
+            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)
         }
 
-        clear()
+        glClear(clearMask)
     }
 
     private fun setupBufferTexture(id: Int) {
@@ -108,12 +120,6 @@ class FrameBuffer {
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
     }
 
-    private fun clear() {
-        glClearColor(0f, 0f, 0f, 0f)
-        glClearDepth(1.0)
-        glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT)
-    }
-
     companion object {
         private val vao = VAO(VertexMode.TRIANGLES, VertexAttrib.Group.POS_UV)
         private var lastFrameBuffer: Int? = null

common/src/main/kotlin/com/lambda/gui/impl/AbstractClickGui.kt

@@ -47,13 +47,15 @@ abstract class AbstractClickGui(name: String, owner: Module? = null) : LambdaGui
 
         when (e) {
             is GuiEvent.Render -> {
-                frameBuffer.write {
-                    windows.onEvent(e)
-                }.read(shader) {
-                    it["u_Progress"] = childShowAnimation
+                if (childShowAnimation < 0.99) {
+                    frameBuffer.write {
+                        windows.onEvent(e)
+                    }.read(shader) {
+                        it["u_Progress"] = childShowAnimation
+                    }
+
+                    return
                 }
-
-                return
             }
 
             is GuiEvent.Show -> {

common/src/main/kotlin/com/lambda/gui/impl/hudgui/LambdaHudGui.kt

@@ -46,7 +46,7 @@ object LambdaHudGui : AbstractClickGui("HudGui") {
                 if (hoveredWindow == null &&
                     e.action == Mouse.Action.Click &&
                     e.button == Mouse.Button.Left
-                ) hudModules.firstOrNull { e.mouse in it.rect }?.let {
+                ) hudModules.filter(Module::isEnabled).firstOrNull { e.mouse in it.rect }?.let {
                     dragInfo = e.mouse - it.position to it
                 }
             }

common/src/main/kotlin/com/lambda/module/HudModule.kt

@@ -5,6 +5,7 @@ import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.gui.api.RenderLayer
 import com.lambda.module.tag.ModuleTag
 import com.lambda.util.KeyCode
+import com.lambda.util.math.MathUtils.coerceIn
 import com.lambda.util.math.Rect
 import com.lambda.util.math.Vec2d
 
@@ -24,40 +25,38 @@ abstract class HudModule(
 
     private var relativePosX by setting("Position X", 0.0, -10000.0..10000.0, 0.1) { false }
     private var relativePosY by setting("Position Y", 0.0, -10000.0..10000.0, 0.1) { false }
-
     private var relativePos get() = Vec2d(relativePosX, relativePosY)
         set(value) { relativePosX = value.x; relativePosY = value.y }
 
-    var position get() = relativeToAbs(relativePos).let {
-        val x = it.x.coerceIn(0.0, screenSize.x - width)
-        val y = it.y.coerceIn(0.0, screenSize.y - height)
-        Vec2d(x, y)
-    }; set(value) {
-        relativePos = absToRelative(value)
-        autoDocking()
-    }
+    var position
+        get() = relativeToAbs(relativePos).coerceIn(0.0, screenSize.x - width, 0.0, screenSize.y - height)
+        set(value) { relativePos = absToRelative(value); if (autoDocking) autoDocking() }
 
-    private fun relativeToAbs(posIn: Vec2d) = posIn + (screenSize - size) * dockingMultiplier
-    private fun absToRelative(posIn: Vec2d) = posIn - (screenSize - size) * dockingMultiplier
+    private val dockingOffset get() = (screenSize - size) * Vec2d(dockingH.multiplier, dockingV.multiplier)
 
-    private val autoDocking by setting("Auto Docking", true)
+    private fun relativeToAbs(posIn: Vec2d) = posIn + dockingOffset
+    private fun absToRelative(posIn: Vec2d) = posIn - dockingOffset
 
-    private var dockingH by setting("Docking H", HAlign.LEFT).apply {
+    private val autoDocking by setting("Auto Docking", true).apply {
+        onValueChange { _, _ ->
+            autoDocking()
+        }
+    }
+
+    private var dockingH by setting("Docking H", HAlign.LEFT) { !autoDocking }.apply {
         onValueChange { from, to ->
             val delta = to.multiplier - from.multiplier
             relativePosX += delta * (size.x - screenSize.x)
         }
     }
 
-    private var dockingV by setting("Docking V", VAlign.TOP).apply {
+    private var dockingV by setting("Docking V", VAlign.TOP) { !autoDocking }.apply {
         onValueChange { from, to ->
             val delta = to.multiplier - from.multiplier
             relativePosY += delta * (size.y - screenSize.y)
         }
     }
 
-    private val dockingMultiplier get() = Vec2d(dockingH.multiplier, dockingV.multiplier)
-
     val rect get() = Rect.basedOn(position, width, height)
 
     private var screenSize = Vec2d.ZERO
@@ -79,8 +78,6 @@ abstract class HudModule(
     }
 
     private fun autoDocking() {
-        if (!autoDocking) return
-
         val screenCenterX = (screenSize.x * 0.3333)..(screenSize.x * 0.6666)
         val screenCenterY = (screenSize.y * 0.3333)..(screenSize.y * 0.6666)
 

common/src/main/kotlin/com/lambda/module/hud/Watermark.kt

@@ -8,7 +8,7 @@ import com.lambda.module.tag.ModuleTag
 
 object Watermark : HudModule(
     name = "Watermark",
-    defaultTags = setOf(ModuleTag.HUD_CLIENT),
+    defaultTags = setOf(ModuleTag.CLIENT),
 ) {
     private val shade by setting("Shade", true)
 

common/src/main/kotlin/com/lambda/module/tag/ModuleTag.kt

@@ -27,8 +27,7 @@ data class ModuleTag(override val name: String) : Nameable {
         val DEBUG = ModuleTag("Debug")
         val defaults = setOf(COMBAT, MOVEMENT, RENDER, PLAYER, NETWORK, DEBUG, CLIENT)
 
-        val HUD_CLIENT = ModuleTag("Client") // omg
-        val hudDefaults = setOf(HUD_CLIENT)
+        val hudDefaults = setOf(CLIENT)
 
         // currently secondary tags
         val WORLD = ModuleTag("World")

common/src/main/kotlin/com/lambda/util/math/MathUtils.kt

@@ -145,4 +145,10 @@ object MathUtils {
             lerp(c1.b, c2.b, p).toFloat(),
             lerp(c1.a, c2.a, p).toFloat()
         )
+
+    fun Vec2d.coerceIn(minX: Double, maxX: Double, minY: Double, maxY: Double) =
+        Vec2d(
+            max(minX, min(x, maxX)),
+            max(minY, min(y, maxY))
+        )
 }