Misc render stuff

Author: Blade-kt

common/src/main/kotlin/com/lambda/graphics/buffer/vertex/attributes/VertexAttrib.kt

@@ -21,76 +21,82 @@ import org.lwjgl.opengl.GL11C.GL_FLOAT
 import org.lwjgl.opengl.GL11C.GL_UNSIGNED_BYTE
 import org.lwjgl.opengl.GL20C.glEnableVertexAttribArray
 import org.lwjgl.opengl.GL20C.glVertexAttribPointer
+import org.lwjgl.opengl.GL33.glVertexAttribDivisor
 
-enum class VertexAttrib(
+sealed class VertexAttrib(
     private val componentCount: Int,
     componentSize: Int,
     private val normalized: Boolean,
+    private val single: Boolean,
     private val type: Int
 ) {
-    Float(1, 4, false, GL_FLOAT),
-    Vec2(2, 4, false, GL_FLOAT),
-    Vec3(3, 4, false, GL_FLOAT),
-    Color(4, 1, true, GL_UNSIGNED_BYTE);
+    open class Float(
+        normalized: Boolean = false, single: Boolean = false
+    ) : VertexAttrib(1, 4, normalized, single, GL_FLOAT) {
+        companion object : Float()
+    }
+
+    open class Vec2(
+        normalized: Boolean = false, single: Boolean = false
+    ) : VertexAttrib(2, 4, normalized, single, GL_FLOAT) {
+        companion object : Vec2()
+    }
+
+    open class Vec3(
+        normalized: Boolean = false, single: Boolean = false
+    ) : VertexAttrib(3, 4, normalized, single, GL_FLOAT) {
+        companion object : Vec3()
+    }
+
+    open class Color(
+        normalized: Boolean = true, single: Boolean = false
+    ) : VertexAttrib(4, 1, normalized, single, GL_UNSIGNED_BYTE) {
+        companion object : Color()
+    }
 
     val size = componentCount * componentSize
 
-    fun pointer(index: Int, pointer: Long, stride: Int) {
+    fun link(index: Int, pointer: Long, stride: Int) {
         glEnableVertexAttribArray(index)
         glVertexAttribPointer(index, componentCount, type, normalized, stride, pointer)
+        if (single) glVertexAttribDivisor(index, 1)
     }
 
-    enum class Group(vararg val attributes: VertexAttrib) {
-        POS_UV(Vec2, Vec2),
+    @Suppress("ClassName")
+    open class Group(vararg val attributes: VertexAttrib) {
+        object POS_UV : Group(Vec2, Vec2)
 
         // GUI
-        FONT(
-            Vec3, // pos
-            Vec2, // uv
-            Color
-        ),
-
-        RECT_FILLED(
-            Vec3, // pos
-            Vec2, // uv
-            Color
-        ),
-
-        RECT_OUTLINE(
-            Vec3, // pos
-            Vec2, // uv
-            Float, // alpha
-            Color
-        ),
+        object FONT : Group(Vec3, Vec2, Color)
+
+        object RECT_FILLED : Group(
+            Vec3, Vec2, Color
+        )
+
+        object RECT_OUTLINE : Group(
+            Vec3, Vec2, Float, Color
+        )
 
         // WORLD
-        DYNAMIC_RENDERER(
-            Vec3, // prev pos
-            Vec3, // pos
-            Color
-        ),
-
-        STATIC_RENDERER(
-            Vec3, // pos
-            Color
-        ),
-
-        PARTICLE(
-            Vec3,
-            Vec2, // pos
-            Color
-        );
+        object DYNAMIC_RENDERER : Group(
+            Vec3, Vec3, Color
+        )
+
+        object STATIC_RENDERER : Group(
+            Vec3, Color
+        )
+
+        object PARTICLE : Group(Vec3, Vec2, Color)
 
         val stride = attributes.sumOf { attribute ->
             attribute.size
         }
 
         fun link() {
             attributes.foldIndexed(0L) { index, pointer, attrib ->
-                attrib.pointer(index, pointer, stride)
+                attrib.link(index, pointer, stride)
                 pointer + attrib.size
             }
         }
     }
 }
-

common/src/main/kotlin/com/lambda/graphics/pipeline/PersistentBuffer.kt

@@ -51,6 +51,7 @@ class PersistentBuffer(
     fun upload() {
         val dataStart = byteBuffer.pointer + uploadOffset
         val dataCount = byteBuffer.bytesPut - uploadOffset
+        if (dataCount <= 0) return
 
         if (glSize != byteBuffer.capacity) {
             glSize = byteBuffer.capacity
@@ -73,7 +74,6 @@ class PersistentBuffer(
         }
 
         glBuffer.update(uploadOffset.toLong(), dataCount, dataStart)
-        println(dataCount)
     }
 
     fun end() {

common/src/main/kotlin/com/lambda/graphics/pipeline/VertexPipeline.kt

@@ -73,7 +73,7 @@ class VertexPipeline(
      */
     fun immediate(block: VertexBuilder.() -> Unit) {
         VertexBuilder(this).apply(block)
-        upload(); render(); clear()
+        uploadInternal(); render(); clear()
     }
 
     /**
@@ -88,7 +88,7 @@ class VertexPipeline(
      */
     fun upload(block: VertexBuilder.() -> Unit) {
         VertexBuilder(this).apply(block)
-        upload()
+        uploadInternal()
     }
 
     /**
@@ -100,7 +100,7 @@ class VertexPipeline(
      */
     fun upload(builder: VertexBuilder) {
         builder.uploadTo(this)
-        upload()
+        uploadInternal()
     }
 
     /**
@@ -114,7 +114,7 @@ class VertexPipeline(
     /**
      * Uploads buffered data to GPU memory
      */
-    fun upload() {
+    private fun uploadInternal() {
         vbo.upload()
         ibo.upload()
     }

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

@@ -27,7 +27,7 @@ import kotlin.math.min
 object FilledRectRenderer : AbstractGUIRenderer(
     VertexAttrib.Group.RECT_FILLED, shader("renderer/rect_filled")
 ) {
-    private const val EXPAND = 0.35
+    private const val EXPAND = 0.4
 
     fun filledRect(
         rect: Rect,

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

@@ -75,7 +75,7 @@ object ClickGui : Module(
     val animationCurve by setting("List Animation Curve", AnimationCurve.Normal)
     val smoothness by setting("Smoothness", 0.4, 0.3..0.7, 0.01) { animationCurve != AnimationCurve.Static }
 
-    val hudPadding by setting("Hud Padding", 3.0, 0.0..10.0, 0.1)
+    val hudPadding by setting("Hud Padding", 2.0, 0.0..10.0, 0.1)
 
     val SCREEN: LambdaScreen by lazy {
         gui("Click Gui") {

common/src/main/kotlin/com/lambda/module/modules/render/Particles.kt

@@ -101,7 +101,7 @@ object Particles : Module(
                 shader.use()
                 shader["u_CameraPosition"] = mc.gameRenderer.camera.pos
 
-                pipeline.upload()
+                pipeline.upload(builder)
                 withDepth(false, pipeline::render)
                 pipeline.clear()
             }

common/src/main/resources/assets/lambda/shaders/renderer/rect_filled.glsl

@@ -13,41 +13,18 @@ uniforms {
 };
 
 #include "rect"
-#define SMOOTHING 0.2
-#define round getRoundAlpha()
+#define SMOOTHING 0.5
 
-float getRoundRadius() {
-    bool xcmp = v_TexCoord.x > 0.5;
-    bool ycmp = v_TexCoord.y > 0.5;
+float roundedRectSDF() {
+    vec4 r = vec4(u_RoundRightBottom, u_RoundRightTop, u_RoundLeftBottom, u_RoundLeftTop);
+    r.xy = (v_TexCoord.x > 0.5) ? r.xy : r.zw;
+    r.x  = (v_TexCoord.y > 0.5) ? r.x  : r.y;
 
-    float r = 0.0;
-
-    if (xcmp) {
-        if (ycmp) { r = u_RoundRightBottom; }
-        else { r = u_RoundRightTop; }
-    } else {
-        if (ycmp) { r = u_RoundLeftBottom; }
-        else { r = u_RoundLeftTop; }
-    }
-
-    return r;
-}#
-
-vec4 getRoundAlpha() {
-    vec2 halfSize = u_Size * 0.5;
-
-    float radius = max(getRoundRadius(), SMOOTHING);
-
-    vec2 smoothVec = vec2(SMOOTHING);
-    vec2 coord = mix(-smoothVec, u_Size + smoothVec, v_TexCoord);
-
-    vec2 center = halfSize - coord;
-    float distance = length(max(abs(center) - halfSize + radius, 0.0)) - radius;
-
-    float alpha = 1.0 - smoothstep(-SMOOTHING, SMOOTHING, distance);
-    return vec4(1.0, 1.0, 1.0, clamp(alpha, 0.0, 1.0));
+    vec2 q = u_Size * (abs(v_TexCoord - 0.5) - 0.5) + r.x;
+    return min(max(q.x, q.y), 0.0) + length(max(q, 0.0)) - r.x;
 }#
 
 void fragment() {
-    color = v_Color * shade * round + noise;
+    float a = 1.0 - smoothstep(-SMOOTHING, 0.0, roundedRectSDF());
+    color = v_Color * vec4(shade.rgb, shade.a * a) + noise;
 }#