New Lambda RenderPipeline using native MC renderer

- Solved precision issues with ESP
- Using MC new render API

Author: Avanatiker

src/main/java/com/lambda/mixin/render/GameRendererMixin.java

@@ -27,13 +27,15 @@
 import com.llamalad7.mixinextras.injector.ModifyReturnValue;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.mojang.blaze3d.buffers.GpuBufferSlice;
 import net.minecraft.client.render.Camera;
 import net.minecraft.client.render.GameRenderer;
 import net.minecraft.client.render.RenderTickCounter;
 import net.minecraft.client.render.WorldRenderer;
 import net.minecraft.client.util.ObjectAllocator;
 import net.minecraft.item.ItemStack;
 import org.joml.Matrix4f;
+import org.joml.Vector4f;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -48,24 +50,12 @@ private void updateTargetedEntityInvoke(float tickDelta, CallbackInfo info) {
         }
     }
 
-    /**
-     * Begins our 3d render after the game has rendered the world
-     * <pre>{@code
-     * float m = Math.max(h, (float)(Integer)this.client.options.getFov().getValue());
-     * Matrix4f matrix4f2 = this.getBasicProjectionMatrix(m);
-     * RenderSystem.setProjectionMatrix(matrix4f, ProjectionType.PERSPECTIVE);
-     * Quaternionf quaternionf = camera.getRotation().conjugate(new Quaternionf());
-     * Matrix4f matrix4f3 = (new Matrix4f()).rotation(quaternionf);
-     * this.client.worldRenderer.setupFrustum(camera.getPos(), matrix4f3, matrix4f2);
-     * this.client.worldRenderer.render(this.pool, renderTickCounter, bl, camera, this, matrix4f3, matrix4f);
-     * }</pre>
-     */
-//    @WrapOperation(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;render(Lnet/minecraft/client/util/ObjectAllocator;Lnet/minecraft/client/render/RenderTickCounter;ZLnet/minecraft/client/render/Camera;Lnet/minecraft/client/render/GameRenderer;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;)V"))
-//    void onRenderWorld(WorldRenderer instance, ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, Matrix4f positionMatrix, Matrix4f projectionMatrix, Operation<Void> original) {
-//        original.call(instance, allocator, tickCounter, renderBlockOutline, camera, gameRenderer, positionMatrix, projectionMatrix);
-//
-//        RenderMain.render3D(positionMatrix, projectionMatrix);
-//    }
+    @WrapOperation(method = "renderWorld", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;render(Lnet/minecraft/client/util/ObjectAllocator;Lnet/minecraft/client/render/RenderTickCounter;ZLnet/minecraft/client/render/Camera;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;Lorg/joml/Matrix4f;Lcom/mojang/blaze3d/buffers/GpuBufferSlice;Lorg/joml/Vector4f;Z)V"))
+    void onRenderWorld(WorldRenderer instance, ObjectAllocator allocator, RenderTickCounter tickCounter, boolean renderBlockOutline, Camera camera, Matrix4f positionMatrix, Matrix4f basicProjectionMatrix, Matrix4f projectionMatrix, GpuBufferSlice fogBuffer, Vector4f fogColor, boolean renderSky, Operation<Void> original) {
+        original.call(instance, allocator, tickCounter, renderBlockOutline, camera, positionMatrix, basicProjectionMatrix, projectionMatrix, fogBuffer, fogColor, renderSky);
+
+        RenderMain.render3D(positionMatrix, projectionMatrix);
+    }
 
     @ModifyExpressionValue(method = "renderWorld", at = @At(value = "INVOKE", target = "Ljava/lang/Math;max(FF)F", ordinal = 0))
     private float modifyMax(float original) {

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

@@ -22,13 +22,14 @@ import com.lambda.event.Event
 import com.lambda.event.callback.Cancellable
 import com.lambda.event.callback.ICancellable
 import com.lambda.event.listener.SafeListener.Companion.listen
+import com.lambda.graphics.RenderMain
 import com.lambda.graphics.renderer.esp.ShapeBuilder
-import com.lambda.graphics.renderer.esp.Treed
 
 fun Any.onStaticRender(block: SafeContext.(ShapeBuilder) -> Unit) =
-    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Static.faceBuilder, Treed.Static.edgeBuilder)) }
+	listen<RenderEvent.Upload> { block(ShapeBuilder(RenderMain.StaticESP)) }
+
 fun Any.onDynamicRender(block: SafeContext.(ShapeBuilder) -> Unit) =
-    listen<RenderEvent.Upload> { block(ShapeBuilder(Treed.Dynamic.faceBuilder, Treed.Dynamic.edgeBuilder)) }
+	listen<RenderEvent.Upload> { block(ShapeBuilder(RenderMain.DynamicESP)) }
 
 sealed class RenderEvent {
     object Upload : Event

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

@@ -17,60 +17,47 @@
 
 package com.lambda.graphics
 
-import com.lambda.Lambda.mc
 import com.lambda.event.EventFlow.post
 import com.lambda.event.events.RenderEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
-import com.lambda.graphics.gl.GlStateUtils.setupGL
 import com.lambda.graphics.gl.Matrices
 import com.lambda.graphics.gl.Matrices.resetMatrices
-import com.lambda.graphics.renderer.esp.Treed
-import com.lambda.util.math.Vec2d
-import com.mojang.blaze3d.opengl.GlStateManager
-import com.mojang.blaze3d.systems.RenderSystem
-import net.minecraft.client.gl.GlBackend
-import net.minecraft.client.texture.GlTexture
+import com.lambda.graphics.mc.LambdaRenderPipelines
+import com.lambda.graphics.mc.TransientRegionESP
 import org.joml.Matrix4f
-import org.lwjgl.opengl.GL30.GL_FRAMEBUFFER
 
 object RenderMain {
-    val projectionMatrix = Matrix4f()
-    val modelViewMatrix get() = Matrices.peek()
-    val projModel: Matrix4f get() = Matrix4f(projectionMatrix).mul(modelViewMatrix)
+    val StaticESP = TransientRegionESP("Static")
+    val DynamicESP = TransientRegionESP("Dynamic")
 
-    var screenSize = Vec2d.ZERO
+    val projectionMatrix = Matrix4f()
+    val modelViewMatrix
+        get() = Matrices.peek()
+    val projModel: Matrix4f
+        get() = Matrix4f(projectionMatrix).mul(modelViewMatrix)
 
     @JvmStatic
     fun render3D(positionMatrix: Matrix4f, projMatrix: Matrix4f) {
         resetMatrices(positionMatrix)
         projectionMatrix.set(projMatrix)
 
-        setupGL {
-            val framebuffer = mc.framebuffer
-            val prevFramebuffer = (framebuffer.getColorAttachment() as GlTexture).getOrCreateFramebuffer(
-                (RenderSystem.getDevice() as GlBackend).bufferManager,
-                null
-            )
-
-            GlStateManager._glBindFramebuffer(GL_FRAMEBUFFER, prevFramebuffer)
+        // Render transient ESPs using the new pipeline
+        StaticESP.render(false) // Depth tested
+        DynamicESP.render(true) // Through walls
 
-            Treed.Static.render()
-            Treed.Dynamic.render()
-
-            RenderEvent.Render.post()
-        }
+        RenderEvent.Render.post()
     }
 
     init {
         listen<TickEvent.Post> {
-            Treed.Static.clear()
-            Treed.Dynamic.clear()
+            StaticESP.clear()
+            DynamicESP.clear()
 
             RenderEvent.Upload.post()
 
-            Treed.Static.upload()
-            Treed.Dynamic.upload()
+            StaticESP.upload()
+            DynamicESP.upload()
         }
     }
 }

src/main/kotlin/com/lambda/graphics/gl/GlStateUtils.kt

@@ -30,6 +30,7 @@ import org.lwjgl.opengl.GL30C.glDisable
 import org.lwjgl.opengl.GL30C.glEnable
 import org.lwjgl.opengl.GL30C.glLineWidth
 
+// ToDo: Migrate particle system so we can remove this
 object GlStateUtils {
     private var depthTestState = true
     private var blendState = false