Color waving

Author: bladekt

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

@@ -11,7 +11,6 @@ class RectEntry(
     override val updateBlock: IRectEntry.() -> Unit
 ) : IRectEntry {
     override var position by owner.field(Rect.ZERO)
-
     override var roundRadius by owner.field(0.0)
 
     private var leftTop     by owner.field(Color.WHITE!!)
@@ -65,7 +64,6 @@ class RectEntry(
 
 interface IRectEntry : IRenderEntry<IRectEntry> {
     var position: Rect
-
     var roundRadius: Double
 
     fun color(leftTop: Color, rightTop: Color, rightBottom: Color, leftBottom: Color)

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

@@ -3,15 +3,35 @@ package com.lambda.graphics.renderer.gui.rect
 import com.lambda.graphics.buffer.vao.vertex.VertexAttrib
 import com.lambda.graphics.renderer.gui.AbstractGuiRenderer
 import com.lambda.graphics.shader.Shader
+import com.lambda.module.modules.client.ClickGui
+import com.lambda.util.math.Vec2d
+import org.lwjgl.glfw.GLFW.glfwGetTime
 
 class RectRenderer : AbstractGuiRenderer<IRectEntry>(
     VertexAttrib.Group.RECT
 ) {
+    var shadeColor = false
+
     override fun render() {
         shader.use()
+
+        shader["u_Shade"] = shadeColor
+
+        if (shadeColor) {
+            shader["u_Time"] = glfwGetTime() * ClickGui.colorSpeed * 3.0
+            shader["u_Color1"] = ClickGui.shadeColor1
+            shader["u_Color2"] = ClickGui.shadeColor2
+            shader["u_Size"] = Vec2d.ONE / Vec2d(ClickGui.colorWidth, ClickGui.colorHeight)
+        }
+
         super.render()
     }
 
+    override fun build(block: IRectEntry.() -> Unit): IRectEntry {
+        shadeColor = false
+        return super.build(block)
+    }
+
     override fun newEntry(block: IRectEntry.() -> Unit) =
         RectEntry(this, block)
 

common/src/main/kotlin/com/lambda/gui/api/layer/RenderLayer.kt

@@ -8,17 +8,18 @@ import com.mojang.blaze3d.systems.RenderSystem.defaultBlendFunc
 import org.lwjgl.opengl.GL11.GL_ONE
 import org.lwjgl.opengl.GL11.GL_SRC_ALPHA
 
-class RenderLayer(private val allowGlowing: Boolean = false) {
-    val rect = RectRenderer().asRenderer
+class RenderLayer(private val allowEffects: Boolean = false) {
+    private val rectRenderer = RectRenderer()
+
+    val rect = rectRenderer.asRenderer
     val font = FontRenderer().asRenderer
 
     fun render() {
         rect.update()
         font.update()
 
-        if (allowGlowing && ClickGui.glow) blendFunc(GL_SRC_ALPHA, GL_ONE)
-        rect.render()
-        defaultBlendFunc()
+        rectRenderer.shadeColor = ClickGui.shade
+        applyFancyBlending(rect::render)
 
         font.render()
     }
@@ -27,4 +28,12 @@ class RenderLayer(private val allowGlowing: Boolean = false) {
         rect.destroy()
         font.destroy()
     }
+
+    private fun applyFancyBlending(block: () -> Unit) {
+        if (ClickGui.glow && allowEffects) {
+            blendFunc(GL_SRC_ALPHA, GL_ONE)
+            block()
+            defaultBlendFunc()
+        } else block()
+    }
 }

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

@@ -22,9 +22,19 @@ object ClickGui : Module(
     val buttonStep by setting("Button Step", 1.0, 0.0..5.0, 0.1, visibility = { page == Page.General })
 
     // Colors
-    val mainColor by setting("Main Color", Color(100, 215, 255), visibility = { page == Page.Colors })
+    private val primaryColor by setting("Primary Color", Color(130, 200, 255), visibility = { page == Page.Colors })
+    private val secondaryColor by setting("Secondary Color", Color(225, 130, 225), visibility = { page == Page.Colors && shade })
     val backgroundColor by setting("Background Color", Color(0, 0, 0, 80), visibility = { page == Page.Colors })
-    val glow by setting("Glow (experimental)", true, visibility = { page == Page.Colors })
+    val glow by setting("Glow", true, visibility = { page == Page.Colors })
+    val shade by setting("Shade Color", true, visibility = { page == Page.Colors })
+    val colorWidth by setting("Color Width", 40.0, 1.0..100.0, 1.0, visibility = { page == Page.Colors && shade })
+    val colorHeight by setting("Color Height", 40.0, 1.0..100.0, 1.0, visibility = { page == Page.Colors && shade })
+    val colorSpeed by setting("Color Speed", 1.0, 0.1..10.0, 0.1, visibility = { page == Page.Colors && shade })
+
+    val mainColor: Color get() = if (shade) Color.WHITE else primaryColor
+
+    val shadeColor1 get() = primaryColor
+    val shadeColor2 get() = secondaryColor
 
     enum class Page {
         General,

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

@@ -1,5 +1,12 @@
 #version 330 core
 
+uniform bool u_Shade;
+uniform float u_Time;
+uniform vec4 u_Color1;
+uniform vec4 u_Color2;
+uniform vec2 u_Size;
+
+in vec2 v_Position;
 in vec2 v_TexCoord;
 in vec4 v_Color;
 in vec2 v_Size;
@@ -9,7 +16,16 @@ out vec4 color;
 
 #define SMOOTHING 0.5
 
-void main() {
+vec4 shade() {
+    if (!u_Shade) return v_Color;
+
+    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) * vec4(1.0, 1.0, 1.0, v_Color.a);
+}
+
+vec4 round() {
     vec2 halfSize = v_Size * 0.5;
 
     float radius = max(v_RoundRadius, SMOOTHING);
@@ -21,7 +37,9 @@ void main() {
     float distance = length(max(abs(center) - halfSize + radius, 0.0)) - radius;
 
     float alpha = 1.0 - smoothstep(-SMOOTHING, SMOOTHING, distance);
-    alpha = clamp(alpha, 0.0, 1.0);
+    return vec4(1.0, 1.0, 1.0, clamp(alpha, 0.0, 1.0));
+}
 
-    color = v_Color * vec4(1.0, 1.0, 1.0, alpha);
+void main() {
+    color = shade() * round();
 }

common/src/main/resources/assets/lambda/shaders/vertex/renderer/rect.vert

@@ -8,6 +8,7 @@ layout (location = 3) in vec4 color;
 uniform mat4 u_Projection;
 uniform mat4 u_ModelView;
 
+out vec2 v_Position;
 out vec2 v_TexCoord;
 out vec4 v_Color;
 out vec2 v_Size;
@@ -16,6 +17,7 @@ out float v_RoundRadius;
 void main() {
     gl_Position = u_Projection * u_ModelView * pos;
 
+    v_Position = pos.xy;
     v_TexCoord = uv;
     v_Color = color;