Watermark, HUD autodocking

Author: bladekt

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

@@ -47,6 +47,8 @@ class FrameBuffer {
         shaderBlock(shader)
 
         vao.use {
+            grow(4)
+
             val uv1 = pos1 / RenderMain.screenSize
             val uv2 = pos2 / RenderMain.screenSize
 

common/src/main/kotlin/com/lambda/graphics/renderer/gui/TextureRenderer.kt

@@ -0,0 +1,57 @@
+package com.lambda.graphics.renderer.gui
+
+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.shader.Shader
+import com.lambda.graphics.texture.Texture
+import com.lambda.module.modules.client.GuiSettings
+import com.lambda.util.math.Rect
+import com.lambda.util.math.Vec2d
+import org.lwjgl.glfw.GLFW.glfwGetTime
+
+object TextureRenderer {
+    private val vao = VAO(VertexMode.TRIANGLES, VertexAttrib.Group.POS_UV)
+    private val shader = Shader("renderer/pos_tex")
+    private val shaderColored = Shader("renderer/pos_tex_shady")
+
+    fun drawTexture(texture: Texture, rect: Rect) {
+        texture.bind()
+        shader.use()
+
+        drawInternal(rect)
+    }
+
+    fun drawTextureShaded(texture: Texture, rect: Rect, shadeWidthScale: Double = 1.0) {
+        texture.bind()
+        shaderColored.use()
+
+        shaderColored["u_Time"] = glfwGetTime() * GuiSettings.colorSpeed * 5.0
+        shaderColored["u_Color1"] = GuiSettings.shadeColor1
+        shaderColored["u_Color2"] = GuiSettings.shadeColor2
+        shaderColored["u_Size"] = RenderMain.screenSize / Vec2d(GuiSettings.colorWidth, GuiSettings.colorHeight) / shadeWidthScale
+
+        drawInternal(rect)
+    }
+
+    private fun drawInternal(rect: Rect) {
+        val pos1 = rect.leftTop
+        val pos2 = rect.rightBottom
+
+        vao.use {
+            grow(4)
+
+            putQuad(
+                vec2(pos1.x, pos1.y).vec2(0.0, 0.0).end(),
+                vec2(pos1.x, pos2.y).vec2(0.0, 1.0).end(),
+                vec2(pos2.x, pos2.y).vec2(1.0, 1.0).end(),
+                vec2(pos2.x, pos1.y).vec2(1.0, 0.0).end()
+            )
+        }
+
+        vao.upload()
+        vao.render()
+        vao.clear()
+    }
+}

common/src/main/kotlin/com/lambda/graphics/texture/MipmapTexture.kt

@@ -3,8 +3,10 @@ package com.lambda.graphics.texture
 import com.lambda.graphics.texture.TextureUtils.rescale
 import com.lambda.graphics.texture.TextureUtils.setupLOD
 import com.lambda.graphics.texture.TextureUtils.upload
+import com.lambda.util.LambdaResource
 import org.lwjgl.opengl.GL14.*
 import java.awt.image.BufferedImage
+import javax.imageio.ImageIO
 
 class MipmapTexture(image: BufferedImage, levels: Int = 4) : Texture() {
     private var lastLod: Float? = null
@@ -32,4 +34,9 @@ class MipmapTexture(image: BufferedImage, levels: Int = 4) : Texture() {
 
         glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, targetLod)
     }
+
+    companion object {
+        fun fromResource(path: String, levels: Int = 4): MipmapTexture =
+            MipmapTexture(ImageIO.read(LambdaResource(path).stream), levels)
+    }
 }

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

@@ -23,27 +23,32 @@ 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) {
-        val vec = absToRelative(relativeToAbs(value))
-        relativePosX = vec.x; relativePosY = vec.y
-    }
+
+    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) }
+    }; set(value) {
+        relativePos = absToRelative(value)
+        autoDocking()
+    }
 
     private fun relativeToAbs(posIn: Vec2d) = posIn + (screenSize - size) * dockingMultiplier
     private fun absToRelative(posIn: Vec2d) = posIn - (screenSize - size) * dockingMultiplier
 
-    private val dockingH by setting("Docking H", HAlign.LEFT).apply {
+    private val autoDocking by setting("Auto Docking", true)
+
+    private var dockingH by setting("Docking H", HAlign.LEFT).apply {
         onValueChange { from, to ->
             val delta = to.multiplier - from.multiplier
             relativePosX += delta * (size.x - screenSize.x)
         }
     }
-    private val dockingV by setting("Docking V", VAlign.TOP).apply {
+
+    private var dockingV by setting("Docking V", VAlign.TOP).apply {
         onValueChange { from, to ->
             val delta = to.multiplier - from.multiplier
             relativePosY += delta * (size.y - screenSize.y)
@@ -72,14 +77,33 @@ abstract class HudModule(
         }
     }
 
-    @Suppress("UNUSED")
+    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)
+
+        val drawableCenter = rect.center
+
+        dockingH = when {
+            drawableCenter.x < screenCenterX.start -> HAlign.LEFT
+            drawableCenter.x > screenCenterX.endInclusive -> HAlign.RIGHT
+            else -> HAlign.CENTER
+        }
+
+        dockingV = when {
+            drawableCenter.y < screenCenterY.start -> VAlign.TOP
+            drawableCenter.y > screenCenterY.endInclusive -> VAlign.BOTTOM
+            else -> VAlign.CENTER
+        }
+    }
+
     enum class HAlign(val multiplier: Float) {
         LEFT(0.0f),
         CENTER(0.5f),
         RIGHT(1.0f)
     }
 
-    @Suppress("UNUSED")
     enum class VAlign(val multiplier: Float) {
         TOP(0.0f),
         CENTER(0.5f),

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

@@ -0,0 +1,25 @@
+package com.lambda.module.hud
+
+import com.lambda.graphics.renderer.gui.TextureRenderer.drawTexture
+import com.lambda.graphics.renderer.gui.TextureRenderer.drawTextureShaded
+import com.lambda.graphics.texture.MipmapTexture
+import com.lambda.module.HudModule
+
+object Watermark : HudModule(
+    "Watermark"
+) {
+    private val shade by setting("Shade", true)
+
+    override val width = 50.0
+    override val height = 50.0
+
+    private val normalTexture = MipmapTexture.fromResource("textures/lambda.png")
+    private val monoTexture = MipmapTexture.fromResource("textures/lambda_mono.png")
+
+    init {
+        onRender {
+            if (shade) drawTextureShaded(monoTexture, rect, 0.1)
+            else drawTexture(normalTexture, rect)
+        }
+    }
+}

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

@@ -26,13 +26,13 @@ object GuiSettings : Module(
 
     // Colors
     val primaryColor by setting("Primary Color", Color(130, 200, 255), visibility = { page == Page.Colors })
-    val secondaryColor by setting("Secondary Color", Color(225, 130, 225), visibility = { page == Page.Colors && (shade || shadeBackground) })
+    val secondaryColor by setting("Secondary Color", Color(225, 130, 225), visibility = { page == Page.Colors })
     val backgroundColor by setting("Background Color", Color(50, 50, 50, 150), visibility = { page == Page.Colors })
     val shade by setting("Shade", true, visibility = { page == Page.Colors })
     val shadeBackground by setting("Shade Background", true, visibility = { page == Page.Colors })
-    val colorWidth by setting("Color Width", 400.0, 10.0..1000.0, 10.0, visibility = { page == Page.Colors && (shade || shadeBackground) })
-    val colorHeight by setting("Color Height", 400.0, 10.0..1000.0, 10.0, visibility = { page == Page.Colors && (shade || shadeBackground) })
-    val colorSpeed by setting("Color Speed", 1.0, 0.1..10.0, 0.1, visibility = { page == Page.Colors && (shade || shadeBackground) })
+    val colorWidth by setting("Shade Width", 400.0, 10.0..1000.0, 10.0, visibility = { page == Page.Colors })
+    val colorHeight by setting("Shade Height", 400.0, 10.0..1000.0, 10.0, visibility = { page == Page.Colors })
+    val colorSpeed by setting("Color Speed", 1.0, 0.1..10.0, 0.1, visibility = { page == Page.Colors })
 
     val mainColor: Color get() = if (shade) Color.WHITE else primaryColor
 

common/src/main/kotlin/com/lambda/module/modules/client/GuiSettings.kt

@@ -0,0 +1,10 @@
+#version 330 core
+
+uniform sampler2D u_Texture;
+
+in vec2 v_TexCoord;
+out vec4 color;
+
+void main() {
+    color = texture(u_Texture, v_TexCoord);
+}

common/src/main/resources/assets/lambda/shaders/fragment/renderer/pos_tex.frag

@@ -0,0 +1,23 @@
+#version 330 core
+
+uniform sampler2D u_Texture;
+uniform float u_Time;
+uniform vec4 u_Color1;
+uniform vec4 u_Color2;
+uniform vec2 u_Size;
+
+in vec2 v_Position;
+in vec2 v_TexCoord;
+
+out vec4 color;
+
+vec4 shade() {
+    vec2 pos = v_Position * u_Size;
+    float p = sin(pos.x - pos.y - u_Time) * 0.5 + 0.5;
+
+    return mix(u_Color1, u_Color2, p);
+}
+
+void main() {
+    color = texture(u_Texture, v_TexCoord) * shade();
+}

common/src/main/resources/assets/lambda/shaders/fragment/renderer/pos_tex_shady.frag

@@ -0,0 +1,15 @@
+#version 330 core
+
+layout (location = 0) in vec4 pos;
+layout (location = 1) in vec2 uv;
+
+uniform mat4 u_ProjModel;
+
+out vec2 v_Position;
+out vec2 v_TexCoord;
+
+void main() {
+    gl_Position = u_ProjModel * pos;
+    v_Position = gl_Position.xy * 0.5 + 0.5;
+    v_TexCoord = uv;
+}