Deferred Rendering

resources/EngineResources/shaders/scene_fragment.glsl

@@ -1,6 +1,6 @@
 #version 450
 
-const int MAX_TEXTURES = 500;
+const int MAX_TEXTURES = 64;
 
 layout(location = 0) in vec2 inTextCoords;
 layout(location = 0) out vec4 outAlbedo;

resources/EngineResources/shaders/scene_opaque_fragment.glsl

@@ -1,6 +1,6 @@
 #version 450
 
-const int MAX_TEXTURES = 500;
+const int MAX_TEXTURES = 64;
 
 layout(location = 0) in vec2 inTextCoords;
 layout(location = 0) out vec4 outAlbedo;

resources/EngineResources/shaders/scene_translucent_fragment.glsl

@@ -1,6 +1,6 @@
 #version 450
 
-const int MAX_TEXTURES = 500;
+const int MAX_TEXTURES = 64;
 
 layout(location = 0) in vec2 inTextCoords;
 layout(location = 0) out vec4 outAlbedo;

src/main/java/net/halbear/Terrain4J/EngineCore/Display/Render.java

@@ -6,7 +6,7 @@ import net.halbear.Terrain4J.EngineCore.Logic.InitData;
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
 import net.halbear.Terrain4J.EngineCore.Vulkan.GUI.GuiRenderer;
 import net.halbear.Terrain4J.EngineCore.Vulkan.GUI.GuiTexture;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Deferred.LightRenderer;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering.LightRenderer;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.TextureCache;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.PostProcessing.PostProcess;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VkModel.*;
@@ -15,7 +15,8 @@ import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.CommandPoo
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.GPUSynchronisation.Fence;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.GPUSynchronisation.Semaphore;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.Queues.Queue;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.DeferredSceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ForwardSceneRender;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRenderer;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.SwapChain.SwapChain;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.SwapChain.SwapChainRender;
@@ -56,15 +57,19 @@ public class Render {
     private final MaterialsCache materialsCache;
     private TextureCache textureCache;
     private EngineConfig.AntiAliasType CurrentAAMode;
+    private final boolean Deferred;
 
     public TextureCache GetTextureCache(){return textureCache;}
     public MaterialsCache GetMaterialsCache(){return materialsCache;}
     public VulkanContext GetVulkanContext(){return RendererContext;}
 
     public EngineConfig.AntiAliasType GetCurrentAAMode(){return CurrentAAMode;}
-    public SceneRender GetSceneRender(){return (SceneRender) sceneRender;}
+    public SceneRenderer GetSceneRender(){return sceneRender;}
+
+    public boolean GetDeferred(){return Deferred;}
 
     public Render(EngineInstance engineInstance) {
+        Deferred = EngineConfig.getInstance().DeferredRendering();
         RendererContext = new VulkanContext(engineInstance.window());
         CurrentFrame = 0;
         GraphicsQueue = new Queue.GraphicsQueue(RendererContext, 0);
@@ -84,9 +89,15 @@ public class Render {
         for(int i = 0; i < SwapChainImageCount; i++){
             RenderCompleteSemaphores[i] = new Semaphore(RendererContext);
         }
-        sceneRender = new SceneRender(RendererContext);
+        if(Deferred) {
-        lightRenderer = new LightRenderer(RendererContext, sceneRender.GetMRTAttachments().GetAllAttachments());
+            sceneRender = new DeferredSceneRender(RendererContext);
-        PostProcessor = new PostProcess(RendererContext,sceneRender.GetCurrentDeferred() ? lightRenderer.GetColourAttachment() : sceneRender.GetAttachmentColour());
+            lightRenderer = new LightRenderer(RendererContext, sceneRender.GetMRTAttachments().GetAllAttachments());
+            PostProcessor = new PostProcess(RendererContext, lightRenderer.getAttachment());
+        } else{
+            sceneRender = new ForwardSceneRender(RendererContext);
+            PostProcessor = new PostProcess(RendererContext, sceneRender.GetAttachmentColour());
+            lightRenderer = null;
+        }
         GuiRender = new GuiRenderer(engineInstance, RendererContext, GraphicsQueue, PostProcessor.GetAttachment());
         swapChainRender = new SwapChainRender(RendererContext,PostProcessor.GetAttachment());
         textureCache = new TextureCache();
@@ -140,9 +151,9 @@ public class Render {
         RendererContext.GetDevice().waitIdle();
         Logger.debug("Waiting Vulkan Context");
         sceneRender.cleanup(RendererContext);
+        if(lightRenderer != null)lightRenderer.cleanup(RendererContext);
         PostProcessor.CleanUp(RendererContext);
         swapChainRender.CleanUp(RendererContext);
-        lightRenderer.CleanUp(RendererContext);
         GuiRender.CleanUp(RendererContext);
         Logger.debug("Dynamic Renderer Cleaned up");
         Arrays.asList(RenderCompleteSemaphores).forEach(i->i.cleanup(RendererContext));
@@ -161,12 +172,13 @@ public class Render {
         textureCache.CleanUp(RendererContext);
         RendererContext.cleanup();
     }
-    public void render(EngineInstance engineInstance){
+    public void DeferredRender(EngineInstance engineInstance){
         SwapChain swapChain = RendererContext.GetSwapChain();
         WaitForFence(CurrentFrame);
+        int imageAcquisitionIndex = CurrentFrame;
 
         int ImageIndex;
-        if (Resize || (ImageIndex = swapChain.FetchNextImage(RendererContext.GetDevice(), PresentCompleteSemaphores[CurrentFrame])) < 0){
+        if (Resize || (ImageIndex = swapChain.FetchNextImage(RendererContext.GetDevice(), PresentCompleteSemaphores[imageAcquisitionIndex])) < 0){
             resize(engineInstance);
             return;
         }
@@ -176,9 +188,8 @@ public class Render {
         RecordingStart(CommandPool, CommandBuffer);
 
         sceneRender.Render(engineInstance,RendererContext,CommandBuffer, modelsCache,materialsCache,CurrentFrame);
-        lightRenderer.Render(RendererContext,CommandBuffer,sceneRender.GetMRTAttachments());
+        lightRenderer.render(RendererContext, CommandBuffer, sceneRender.GetMRTAttachments());
-        PostProcessor.Render(RendererContext,CommandBuffer,sceneRender.GetCurrentDeferred() ? lightRenderer.GetColourAttachment() : sceneRender.GetAttachmentColour());
+        PostProcessor.Render(RendererContext,CommandBuffer,lightRenderer.getAttachment());
-
         GuiRender.Render(RendererContext,CommandBuffer,CurrentFrame,PostProcessor.GetAttachment());
 
         swapChainRender.Render(RendererContext,CommandBuffer,PostProcessor.GetAttachment(),ImageIndex);
@@ -189,6 +200,36 @@ public class Render {
         CurrentFrame = (CurrentFrame + 1) % VulkanUtils.MAX_IN_FLIGHT;
     }
 
+    public void ForwardRender(EngineInstance engineInstance){
+        SwapChain swapChain = RendererContext.GetSwapChain();
+        WaitForFence(CurrentFrame); //problem child found
+        var CommandPool = CommandPools[CurrentFrame];
+        var CommandBuffer = CommandBuffers[CurrentFrame];
+        RecordingStart(CommandPool, CommandBuffer);
+
+        sceneRender.Render(engineInstance,RendererContext,CommandBuffer, modelsCache,materialsCache,CurrentFrame);
+        PostProcessor.Render(RendererContext,CommandBuffer,sceneRender.GetAttachmentColour());
+        GuiRender.Render(RendererContext,CommandBuffer,CurrentFrame,PostProcessor.GetAttachment());
+
+        int ImageIndex;
+        if (Resize || (ImageIndex = swapChain.FetchNextImage(RendererContext.GetDevice(), PresentCompleteSemaphores[CurrentFrame])) < 0){
+            resize(engineInstance);
+            return;
+        }
+
+        swapChainRender.Render(RendererContext,CommandBuffer,PostProcessor.GetAttachment(),ImageIndex);
+
+        RecordingStop(CommandBuffer);
+        Submit(CommandBuffer, CurrentFrame, ImageIndex);
+        Resize = swapChain.PresentImage(PresentQueue, RenderCompleteSemaphores[ImageIndex],ImageIndex);
+        CurrentFrame = (CurrentFrame + 1) % VulkanUtils.MAX_IN_FLIGHT;
+    }
+
+    public void render(EngineInstance engineInstance){
+        if(Deferred) DeferredRender(engineInstance);
+        else ForwardRender(engineInstance);
+    }
+
     private void resize(EngineInstance engineInstance){
         Window window = engineInstance.window();
         if(window.getWidth() == 0 && window.getHeight() == 0){
@@ -210,8 +251,12 @@ public class Render {
         VkExtent2D extend = RendererContext.GetSwapChain().GetSwapChainExtent();
         engineInstance.scene().GetProjection().Resize(extend.width(),extend.height());
         sceneRender.Resize(engineInstance,RendererContext);
-        lightRenderer.Resize(RendererContext,sceneRender.GetMRTAttachments().GetAllAttachments());
+        if(Deferred) {
-        PostProcessor.Resize(RendererContext,sceneRender.GetCurrentDeferred() ? lightRenderer.GetColourAttachment() : sceneRender.GetAttachmentColour());
+            lightRenderer.resize(RendererContext, sceneRender.GetMRTAttachments().GetAllAttachments());
+            PostProcessor.Resize(RendererContext, lightRenderer.getAttachment());
+        } else{
+            PostProcessor.Resize(RendererContext, sceneRender.GetAttachmentColour());
+        }
         GuiRender.Resize(RendererContext,PostProcessor.GetAttachment());
         swapChainRender.Resize(RendererContext,PostProcessor.GetAttachment());
     }

src/main/java/net/halbear/Terrain4J/EngineCore/Logic/EngineConfig.java

@@ -1,7 +1,8 @@
 package net.halbear.Terrain4J.EngineCore.Logic;
 
 import net.halbear.Terrain4J.EngineCore.Main.PrimaryRuntime;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.DeferredSceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ForwardSceneRender;
 import org.tinylog.Logger;
 
 import java.io.*;
@@ -218,7 +219,8 @@ public class EngineConfig {
             renderer = Integer.parseInt(EngineConfigVar.getOrDefault("Renderer", 1).toString()) == 0 ? Renderer.Forward: Renderer.Deferred;
             CompatibilityMode = Boolean.parseBoolean(EngineConfigVar.getOrDefault("compatibility_mode", false).toString());
             AlphaToCoverage = Boolean.parseBoolean(EngineConfigVar.getOrDefault("AlphaToCoverage", false).toString());
-            SceneRender.SetDualPassRendering(Boolean.parseBoolean(EngineConfigVar.getOrDefault("DualPassRendering", true).toString()));
+            ForwardSceneRender.SetDualPassRendering(Boolean.parseBoolean(EngineConfigVar.getOrDefault("DualPassRendering", true).toString()));
+            DeferredSceneRender.SetDualPassRendering(Boolean.parseBoolean(EngineConfigVar.getOrDefault("DualPassRendering", true).toString()));
             switch(AAValue){
                 case 0:
                     AAMode = AntiAliasType.NONE;

src/main/java/net/halbear/Terrain4J/EngineCore/Main/GameCore.java

@@ -12,7 +12,10 @@ import net.halbear.Terrain4J.EngineCore.Audio.SoundListener;
 import net.halbear.Terrain4J.EngineCore.Display.Window;
 import net.halbear.Terrain4J.EngineCore.Input.KeyboardInput;
 import net.halbear.Terrain4J.EngineCore.Input.MouseListener;
-import net.halbear.Terrain4J.EngineCore.Logic.*;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineInstance;
+import net.halbear.Terrain4J.EngineCore.Logic.GameLogic;
+import net.halbear.Terrain4J.EngineCore.Logic.InitData;
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.ModelLoader;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.*;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.GUIs.PerformanceOverlay;
@@ -21,7 +24,7 @@ import net.halbear.Terrain4J.EngineCore.Profiling.GPUProfiler;
 import net.halbear.Terrain4J.EngineCore.Vulkan.GUI.GuiTexture;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VkModel.MaterialData;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VkModel.ModelData;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ForwardSceneRender;
 import org.joml.Vector2f;
 import org.joml.Vector3f;
 import org.lwjgl.openal.AL11;
@@ -29,7 +32,6 @@ import org.tinylog.Logger;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.UnaryOperator;
 
 import static org.lwjgl.glfw.GLFW.*;
 
@@ -313,16 +315,17 @@ public class GameCore implements GameLogic {
     public void SecondUpdate(EngineInstance engineInstance) {
         SettingPerformanceMetrics.clear();
         List<String[]> Metrics = new ArrayList<>();
-        String[] SceneDetails = new String[7];
+        String[] SceneDetails = new String[8];
         Vector3f Position = engineInstance.scene().GetCamera().GetPosition();
         Vector3f Rotation = engineInstance.scene().GetCamera().GetRotation();
         SceneDetails[0] = String.format("INSTANCE INFORMATION: ");
         SceneDetails[1] = String.format("  Camera Position: X: %.2f Y: %.2f Z: %.2f",Position.x ,Position.y ,Position.z);
         SceneDetails[2] = String.format("  Camera Rotation: X: %.2f° Y: %.2f° Z: %.2f°",Rotation.x *EngineConfig.RadToDeg,Rotation.y *EngineConfig.RadToDeg ,Rotation.z *EngineConfig.RadToDeg);
         SceneDetails[3] = String.format("  Anti Aliasing: " + EngineConfig.getInstance().RenderAAType().name());
-        SceneDetails[4] = String.format("  Pipeline: " + (SceneRender.DualPassRendering() ? " Dual Pass" : "Single Pass"));
+        SceneDetails[4] = String.format("  Renderer: " + (PrimaryRuntime.GetRenderThread().GetRenderer().GetDeferred() ? " Deferred" : "Forward"));
-        SceneDetails[5] = String.format("  AlphaToCoverage: " + EngineConfig.getInstance().AlphaToCoverage());
+        SceneDetails[5] = String.format("  Pipeline: " + (ForwardSceneRender.DualPassRendering() ? " Dual Pass" : "Single Pass"));
-        SceneDetails[6] = String.format("  FOV: %.2f°",(EngineConfig.getInstance().GetFOV()*EngineConfig.RadToDeg));
+        SceneDetails[6] = String.format("  AlphaToCoverage: " + EngineConfig.getInstance().AlphaToCoverage());
+        SceneDetails[7] = String.format("  FOV: %.2f°",(EngineConfig.getInstance().GetFOV()*EngineConfig.RadToDeg));
         String[] DeviceInfo = new String[5];
         DeviceInfo[0] = String.format("SYSTEM INFORMATION: ");
         DeviceInfo[1] = String.format("  CPU: " + EngineConfig.getInstance().GetCPUDetails());

src/main/java/net/halbear/Terrain4J/EngineCore/Main/PrimaryRuntime.java

@@ -2,7 +2,10 @@ package net.halbear.Terrain4J.EngineCore.Main;
 
 import net.halbear.Terrain4J.EngineCore.Audio.AudioManager;
 import net.halbear.Terrain4J.EngineCore.Display.Window;
-import net.halbear.Terrain4J.EngineCore.Logic.*;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineInstance;
+import net.halbear.Terrain4J.EngineCore.Logic.GameLogic;
+import net.halbear.Terrain4J.EngineCore.Logic.InitData;
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.Scene;
 import net.halbear.Terrain4J.EngineCore.Profiling.CPUMonitor;

src/main/java/net/halbear/Terrain4J/EngineCore/Main/Scene/Camera.java

@@ -3,7 +3,6 @@ package net.halbear.Terrain4J.EngineCore.Main.Scene;
 import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
 import org.joml.Matrix4f;
 import org.joml.Vector3f;
-import org.tinylog.Logger;
 
 public class Camera {
     private final Vector3f Direction;

src/main/java/net/halbear/Terrain4J/EngineCore/Main/Scene/GUIs/PerformanceOverlay.java

@@ -9,8 +9,10 @@ import net.halbear.Terrain4J.EngineCore.Main.GameCore;
 import net.halbear.Terrain4J.EngineCore.Main.PrimaryRuntime;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.GUIOverlay;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.JackOfAllTradesActor;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.DeferredSceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ForwardSceneRender;
 import org.joml.Vector3f;
+import org.tinylog.Logger;
 
 public class PerformanceOverlay implements GUIOverlay {
     @Override
@@ -40,7 +42,8 @@ public class PerformanceOverlay implements GUIOverlay {
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 2000;
             parent.NextAAMode = (0);
-            SceneRender.SetDualPassRendering(false);
+            ForwardSceneRender.SetDualPassRendering(false);
+            DeferredSceneRender.SetDualPassRendering(false);
             EngineConfig.getInstance().SetAlphaToCoverage(false);
             PrimaryRuntime.GetRenderThread().GetRenderer().GetSceneRender().RebuildPipelines(PrimaryRuntime.GetRenderThread().GetRenderer().GetVulkanContext());
         }
@@ -49,7 +52,8 @@ public class PerformanceOverlay implements GUIOverlay {
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 2000;
             parent.NextAAMode = (1);
-            SceneRender.SetDualPassRendering(true);
+            ForwardSceneRender.SetDualPassRendering(true);
+            DeferredSceneRender.SetDualPassRendering(true);
             EngineConfig.getInstance().SetAlphaToCoverage(true);
             PrimaryRuntime.GetRenderThread().GetRenderer().GetSceneRender().RebuildPipelines(PrimaryRuntime.GetRenderThread().GetRenderer().GetVulkanContext());
         }
@@ -58,7 +62,8 @@ public class PerformanceOverlay implements GUIOverlay {
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 2000;
             parent.NextAAMode = (4);
-            SceneRender.SetDualPassRendering(true);
+            ForwardSceneRender.SetDualPassRendering(true);
+            DeferredSceneRender.SetDualPassRendering(true);
             EngineConfig.getInstance().SetAlphaToCoverage(false);
             PrimaryRuntime.GetRenderThread().GetRenderer().GetSceneRender().RebuildPipelines(PrimaryRuntime.GetRenderThread().GetRenderer().GetVulkanContext());
         }
@@ -97,24 +102,29 @@ public class PerformanceOverlay implements GUIOverlay {
         if(ImGui.button("Single Pass")){
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 500;
-            SceneRender.SetDualPassRendering(false);
+            ForwardSceneRender.SetDualPassRendering(false);
+            DeferredSceneRender.SetDualPassRendering(false);
         }
         ImGui.sameLine();
         if(ImGui.button("dual Pass")){
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 500;
-            SceneRender.SetDualPassRendering(true);
+            ForwardSceneRender.SetDualPassRendering(true);
+            DeferredSceneRender.SetDualPassRendering(true);
         }
         if(ImGui.button("Forward Rendering")){
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 500;
             EngineConfig.getInstance().SetRenderer(EngineConfig.Renderer.Forward);
+            //PrimaryRuntime.GetRenderThread().RefreshRenderer();
         }
         ImGui.sameLine();
         if(ImGui.button("Deferred Rendering")){
+            Logger.debug("Enabling Deferred Rendering");
             parent.ChangeGraphicsSettings = true;
             parent.CoolDown = 500;
             EngineConfig.getInstance().SetRenderer(EngineConfig.Renderer.Deferred);
+           // PrimaryRuntime.GetRenderThread().RefreshRenderer();
         }
         if(ImGui.button("AlphaToCoverage False")){
             parent.ChangeGraphicsSettings = true;

src/main/java/net/halbear/Terrain4J/EngineCore/Main/Scene/JackOfAllTradesActor.java

@@ -5,8 +5,6 @@ import net.halbear.Terrain4J.EngineCore.Audio.AudioSource;
 import net.halbear.Terrain4J.EngineCore.Audio.SoundBuffer;
 import net.halbear.Terrain4J.EngineCore.Logic.EngineInstance;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VkModel.ModelData;
-import org.joml.Matrix4f;
-import org.joml.Quaternionf;
 import org.joml.Vector3f;
 
 import java.util.ArrayList;

src/main/java/net/halbear/Terrain4J/EngineCore/Main/Scene/ParticleActor.java

@@ -1,8 +1,6 @@
 package net.halbear.Terrain4J.EngineCore.Main.Scene;
 
 import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
-import org.joml.Matrix4f;
-import org.joml.Quaternionf;
 import org.joml.Vector3f;
 
 public class ParticleActor extends Actor {

src/main/java/net/halbear/Terrain4J/EngineCore/Main/Scene/Scene.java

@@ -1,7 +1,7 @@
 package net.halbear.Terrain4J.EngineCore.Main.Scene;
 
 import net.halbear.Terrain4J.EngineCore.Display.Window;
-import net.halbear.Terrain4J.EngineCore.Logic.*;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Projection.Project3D;
 import org.joml.Vector3f;
 

src/main/java/net/halbear/Terrain4J/EngineCore/Threads/RenderThread.java

@@ -5,13 +5,10 @@ import net.halbear.Terrain4J.EngineCore.Display.Window;
 import net.halbear.Terrain4J.EngineCore.Logic.*;
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
 import net.halbear.Terrain4J.EngineCore.Main.PrimaryRuntime;
-import net.halbear.Terrain4J.EngineCore.Profiling.CPUMonitor;
 import net.halbear.Terrain4J.EngineCore.Profiling.GPUProfiler;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.SceneRender;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.DeferredSceneRender;
 import org.tinylog.Logger;
 
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
 public class RenderThread extends EngineThread {
@@ -42,18 +39,21 @@ public class RenderThread extends EngineThread {
 
     }
 
+    public void RefreshRenderer(){
+        render.cleanup();
+        render = new Render(PrimaryRuntime.GetEngineInstance());
+        render.Initialise(initData);
+    }
 
     @Override
     public void SecondEvent(){
-        EngineConfig.LAST_AVERAGE_GPU_TIME = SceneRender.GetGPUTimeNS();
+        EngineConfig.LAST_AVERAGE_GPU_TIME = DeferredSceneRender.GetGPUTimeNS();
         List<String[]> Profiling =GPUProfiler.GetVramUsage(render.GetVulkanContext().GetPhysicalDevice().GetPhysicalDevice());
         EngineConfig.getInstance().SetMemoryProfiling(Profiling);
         EngineConfig.FrameRate_RENDERTHREAD = Frames;
         EngineConfig.TPS_RENDERTHREAD = TickFrames;
-        if(render.GetCurrentAAMode() != EngineConfig.getInstance().RenderAAType() || render.GetSceneRender().GetCurrentDeferred() != EngineConfig.getInstance().DeferredRendering()){
+        if(render.GetCurrentAAMode() != EngineConfig.getInstance().RenderAAType()  || render.GetDeferred() != EngineConfig.getInstance().DeferredRendering()){
-            render.cleanup();
+            RefreshRenderer();
-            render = new Render(PrimaryRuntime.GetEngineInstance());
-            render.Initialise(initData);
         }
     }
 

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/GUI/GuiRenderer.java

@@ -149,6 +149,7 @@ public class GuiRenderer {
             DescriptorSet descriptorSet = descriptorAllocator.AddDescriptorSets(device, descriptorID, 1, TextDescriptorSetLayout)[0];
             Texture texture = textureCache.GetTexture(guiTexture.TexturePath());
             descriptorSet.SetImage(device,texture.GetImageView(),FontsTextureSampler,TextDescriptorSetLayout.GetLayoutInfo().Binding());
+            //Logger.debug("TEXTURE ID -> [{}] DESCRIPTOR SET -> [{}] TEXTURE -> [{}] IMAGE PATH -> [{}] TEXTURE SAMPLER ->[{}]",guiTexture.ID(),descriptorSet.GetVkDescriptorSet(),texture,guiTexture.TexturePath(),FontsTextureSampler);
             GuiTexturesMap.put(guiTexture.ID(),descriptorSet.GetVkDescriptorSet());
         }
     }
@@ -166,6 +167,7 @@ public class GuiRenderer {
         ByteBuffer buffer = imGuiIO.getFonts().getTexDataAsRGBA32(textureWidth,textureHeight);
         ImageSrc imageSrc = new ImageSrc(buffer,textureWidth.get(),textureHeight.get(),4);
         Texture FontsTexture = new Texture(VkCtx, "GUI_TEXTURE",imageSrc,VK_FORMAT_R8G8B8A8_SRGB);
+
         var commandPool = new CommandPool(VkCtx, queue.GetQueueFamilyIndex(), false);
         var commandBuffer = new CommandBuffer(VkCtx, commandPool, true, true);
         commandBuffer.BeginRecording();

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/Deferred/LightRenderer.java

@@ -1,213 +0,0 @@
-package net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Deferred;
-
-import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
-import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.EmptyVertexBufferStruct;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.DefaultPipeline;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Image;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Pipeline;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.PipelineBuildInfo;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.PostProcessing.SpecializationConstants;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Shader.*;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.CommandBuffer;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.Device;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ImageView;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.SwapChain.SwapChain;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Util.VulkanUtils;
-import org.lwjgl.system.MemoryStack;
-import org.lwjgl.util.shaderc.Shaderc;
-import org.lwjgl.vulkan.*;
-
-import java.nio.LongBuffer;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.lwjgl.vulkan.VK13.*;
-
-public class LightRenderer {
-    private static final int COLOUR_FORMAT = VK_FORMAT_R32G32B32A32_SFLOAT;
-    private static final String DESCRIPTOR_ID_ATTACHMENT = "LIGHT_DESC_ID_ATT";
-    private static final String FRAGMENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/lighting_frag.glsl";
-    private static final String FRAGMENT_SHADER_FILE_SPV = FRAGMENT_SHADER_FILE_GLSL + ".spv";
-    private static final String VERTEX_SHADER_FILE_GLSL = "resources/EngineResources/shaders/lighting_vertex.glsl";
-    private static final String VERTEX_SHADER_FILE_SPV = VERTEX_SHADER_FILE_GLSL + ".spv";
-
-    private final DescriptorSetLayout AttachmentDescriptorSetLayout;
-    private final VkClearValue ClearValueColour;
-    private final Pipeline pipeline;
-    private final TextureSampler textureSampler;
-    private Attachment AttachmentColour;
-    private VkRenderingAttachmentInfo.Buffer AttachmentInfoColour;
-    private VkRenderingInfo RenderingInfo;
-
-    public LightRenderer(VulkanContext VkCtx, List<Attachment> attachmentList){
-        ClearValueColour=VkClearValue.calloc().color(
-                c->c.float32(0,0.0f).float32(1,0.0f).float32(2,0.0f).float32(3,0.0f));
-        AttachmentColour = CreateColourAttachment(VkCtx);
-        AttachmentInfoColour = CreateColourAttachmentInfo(AttachmentColour,ClearValueColour);
-        RenderingInfo = CreateRenderInfo(AttachmentColour,AttachmentInfoColour);
-
-        ShaderModule[] shaderModules = CreateShaderModules(VkCtx);
-
-        var textureSamplerInfo = new TextureSamplerInfo(VK_SAMPLER_ADDRESS_MODE_REPEAT,VK_BORDER_COLOR_INT_OPAQUE_BLACK,1,true);
-        textureSampler = new TextureSampler(VkCtx, textureSamplerInfo);
-        int AttachmentCount = attachmentList.size();
-        DescriptorSetLayout.LayoutInformation[] descriptorSetLayouts = new DescriptorSetLayout.LayoutInformation[AttachmentCount];
-        for(int i = 0; i < AttachmentCount; i++){
-            descriptorSetLayouts[i] = new DescriptorSetLayout.LayoutInformation(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, i,1,VK_SHADER_STAGE_FRAGMENT_BIT);
-        }
-        AttachmentDescriptorSetLayout = new DescriptorSetLayout(VkCtx, descriptorSetLayouts);
-        CreateAttachmentDescriptorSet(VkCtx, AttachmentDescriptorSetLayout, attachmentList, textureSampler);
-
-        pipeline = CreatePipeline(VkCtx,shaderModules,new DescriptorSetLayout[]{AttachmentDescriptorSetLayout});
-        Arrays.asList(shaderModules).forEach(s->{s.CleanUp(VkCtx);});
-    }
-
-    private static Attachment CreateColourAttachment(VulkanContext VkCtx){
-        SwapChain swapChain = VkCtx.GetSwapChain();
-        VkExtent2D SwapChainExtent = swapChain.GetSwapChainExtent();
-        return new Attachment(VkCtx,SwapChainExtent.width(),SwapChainExtent.height(),
-                COLOUR_FORMAT,VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
-    }
-
-    private static VkRenderingAttachmentInfo.Buffer CreateColourAttachmentInfo(Attachment SrcAttachment, VkClearValue ClearValue){
-        return VkRenderingAttachmentInfo.calloc(1)
-                .sType$Default()
-                .imageView(SrcAttachment.GetVkImageView().GetVulkanImageView())
-                .imageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
-                .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
-                .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
-                .clearValue(ClearValue);
-    }
-
-    private static Pipeline CreatePipeline(VulkanContext VkCtx, ShaderModule[] shaderModules, DescriptorSetLayout[] descriptorSetLayouts){
-        var VertexBufferStruct = new EmptyVertexBufferStruct();
-        var BuildInfo = new PipelineBuildInfo(shaderModules,VertexBufferStruct.GetVertexInput(),COLOUR_FORMAT)
-                .SetDescriptorSetLayouts(descriptorSetLayouts)
-                .BlendingIsUsed(true)
-                .SetDepthWrite(false)
-                .SetDepthTest(false);
-        var PipeLine = new DefaultPipeline(VkCtx,BuildInfo);
-        VertexBufferStruct.CleanUp();
-        return PipeLine;
-    }
-
-    private static VkRenderingInfo CreateRenderInfo(Attachment ColourAttachment, VkRenderingAttachmentInfo.Buffer ColourAttachmentInfo){
-        VkRenderingInfo renderingInfo;
-        try(var MemStack = MemoryStack.stackPush()){
-            Image image = ColourAttachment.GetVkImage();
-            VkExtent2D extent2D = VkExtent2D.calloc(MemStack).width(image.GetWidth()).height(image.GetHeight());
-            var RenderArea = VkRect2D.calloc(MemStack).extent(extent2D);
-
-            renderingInfo = VkRenderingInfo.calloc()
-                    .sType$Default()
-                    .renderArea(RenderArea)
-                    .layerCount(1)
-                    .pColorAttachments(ColourAttachmentInfo);
-        }
-        return renderingInfo;
-    }
-
-    private static void CreateAttachmentDescriptorSet(VulkanContext VkCtx, DescriptorSetLayout descriptorSetLayout, List<Attachment> attachments, TextureSampler textureSampler){
-        DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
-        Device device = VkCtx.GetDevice();
-        DescriptorSet descriptorSet = descriptorAllocator.AddDescriptorSet(device, DESCRIPTOR_ID_ATTACHMENT, descriptorSetLayout);
-        List<ImageView> imageViews = new ArrayList<>();
-        attachments.forEach(a->imageViews.add(a.GetVkImageView()));
-        descriptorSet.SetImages(device, imageViews, textureSampler, 0);
-    }
-
-    private static ShaderModule[] CreateShaderModules(VulkanContext VkCtx){
-        if(EngineConfig.getInstance().RecompileShaders()){
-            ShaderCompiler.CompileGLSLShaderOnChange(VERTEX_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_vertex_shader);
-            ShaderCompiler.CompileGLSLShaderOnChange(FRAGMENT_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_fragment_shader);
-        }
-        return new ShaderModule[]{
-                new ShaderModule(VkCtx,VK_SHADER_STAGE_VERTEX_BIT,VERTEX_SHADER_FILE_SPV,null),
-                new ShaderModule(VkCtx,VK_SHADER_STAGE_FRAGMENT_BIT,FRAGMENT_SHADER_FILE_SPV,null)
-        };
-    }
-
-    public Attachment GetColourAttachment(){
-        return AttachmentColour;
-    }
-
-    public void Render(VulkanContext VkCtx, CommandBuffer commandBuffer, MultiRenderTargetAttachments MRTAttachments){
-        try(var MemStack = MemoryStack.stackPush()){
-            VkCommandBuffer CommandHandle = commandBuffer.GetVulkanCommandBuffer();
-
-            VulkanUtils.ImageBarrier(MemStack, CommandHandle, AttachmentColour.GetVkImage().getVulkanImage(),
-                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                    VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
-                    VK_ACCESS_2_NONE, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
-
-            List<Attachment> ColourAttachments = MRTAttachments.GetColourAttachments();
-            int AttachmentCount = ColourAttachments.size();
-            for(int i = 0; i < AttachmentCount; i++) {
-                Attachment colourAttachment = ColourAttachments.get(i);
-                VulkanUtils.ImageBarrier(MemStack, CommandHandle, colourAttachment.GetVkImage().getVulkanImage(),
-                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                        VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
-                        VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
-            }
-            VulkanUtils.ImageBarrier(MemStack, CommandHandle, MRTAttachments.GetDepthAttachment().GetVkImage().getVulkanImage(),
-                    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                    VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
-                    VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,VK_ACCESS_2_SHADER_READ_BIT,
-                    VK_IMAGE_ASPECT_DEPTH_BIT);
-
-            vkCmdBeginRendering(CommandHandle, RenderingInfo);
-
-            vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.GetVulkanPipeline());
-
-            Image colourImage = AttachmentColour.GetVkImage();
-            int width = colourImage.GetWidth();
-            int height = colourImage.GetHeight();
-            var Viewport = VkViewport.calloc(1,MemStack)
-                    .x(0)
-                    .y(height)
-                    .height(-height)
-                    .width(width)
-                    .minDepth(0.0F)
-                    .maxDepth(1.0F);
-            vkCmdSetViewport(CommandHandle, 0, Viewport);
-            var Scissor = VkRect2D.calloc(1,MemStack)
-                    .extent(it -> it.width(width).height(height))
-                    .offset(it->it.x(0).y(0));
-            vkCmdSetScissor(CommandHandle, 0, Scissor);
-
-            DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
-            LongBuffer DescriptorSets = MemStack.mallocLong(1)
-                    .put(0,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_ATTACHMENT).GetVkDescriptorSet());
-            vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.GetVulkanPipelineLayout(),0,DescriptorSets,null);
-            vkCmdDraw(CommandHandle,3,1,0,0);
-            vkCmdEndRendering(CommandHandle);
-        }
-    }
-
-    public void Resize(VulkanContext VkCtx, List<Attachment> attachments){
-        RenderingInfo.free();
-        AttachmentInfoColour.free();
-        AttachmentColour.CleanUp(VkCtx);
-
-        AttachmentColour = CreateColourAttachment(VkCtx);
-        AttachmentInfoColour = CreateColourAttachmentInfo(AttachmentColour, ClearValueColour);
-        RenderingInfo = CreateRenderInfo(AttachmentColour, AttachmentInfoColour);
-        DescriptorSet descriptorSet = VkCtx.GetDescriptorAllocator().GetDescriptorSet(DESCRIPTOR_ID_ATTACHMENT);
-        var ImageViews = new ArrayList<ImageView>();
-        attachments.forEach(a->ImageViews.add(a.GetVkImageView()));
-        descriptorSet.SetImages(VkCtx.GetDevice(),ImageViews,textureSampler,0);
-    }
-
-    public void CleanUp(VulkanContext VkCtx){
-        pipeline.CleanUp(VkCtx);
-        AttachmentDescriptorSetLayout.CleanUp(VkCtx);
-        textureSampler.CleanUp(VkCtx);
-        RenderingInfo.free();
-        AttachmentColour.CleanUp(VkCtx);
-        AttachmentInfoColour.free();
-        ClearValueColour.free();
-    }
-}

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/DeferredRendering/LightRenderer.java

@@ -0,0 +1,224 @@
+package net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering;
+
+import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
+import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.EmptyVertexBufferStruct;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.DefaultPipeline;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Image;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Pipeline;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.PipelineBuildInfo;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Shader.*;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.CommandBuffer;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.Device;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen.ImageView;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.SwapChain.SwapChain;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Util.VulkanUtils;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.util.shaderc.Shaderc;
+import org.lwjgl.vulkan.*;
+
+import java.nio.LongBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.lwjgl.vulkan.VK10.*;
+import static org.lwjgl.vulkan.VK13.*;
+
+public class LightRenderer {
+    private static final int COLOUR_FORMAT = VK_FORMAT_R32G32B32A32_SFLOAT;
+    private static final String DESC_ID_ATT = "LIGHT_DESC_ID_ATT";
+    private static final String FRAGMENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/lighting_frag.glsl";
+    private static final String FRAGMENT_SHADER_FILE_SPV = FRAGMENT_SHADER_FILE_GLSL + ".spv";
+    private static final String VERTEX_SHADER_FILE_GLSL = "resources/EngineResources/shaders/lighting_vertex.glsl";
+    private static final String VERTEX_SHADER_FILE_SPV = VERTEX_SHADER_FILE_GLSL + ".spv";
+
+    private final DescriptorSetLayout AttachmentDescriptorSetLayout;
+    private final VkClearValue ClearValueColour;
+    private final Pipeline pipeline;
+    private final TextureSampler textureSampler;
+    private Attachment AttachmentColour;
+    private VkRenderingAttachmentInfo.Buffer AttachmentInfoColour;
+    private VkRenderingInfo RenderInfo;
+
+    public LightRenderer(VulkanContext VkCtx, List<Attachment> attachments){
+        ClearValueColour = VkClearValue.calloc().color(
+                c -> c.float32(0, 0.0f).float32(1, 0.0f).float32(2, 0.0f).float32(3, 0.0f));
+
+        AttachmentColour = CreateColourAttachment(VkCtx);
+        AttachmentInfoColour = CreateColourAttachmentInfo(AttachmentColour, ClearValueColour);
+        RenderInfo = CreateRenderInfo(AttachmentColour, AttachmentInfoColour);
+
+        ShaderModule[] shaderModules = CreateShaderModules(VkCtx);
+
+        var textureSamplerInfo = new TextureSamplerInfo(VK_SAMPLER_ADDRESS_MODE_REPEAT,
+                VK_BORDER_COLOR_INT_OPAQUE_BLACK, 1, true);
+        textureSampler = new TextureSampler(VkCtx, textureSamplerInfo);
+        int numAttachments = attachments.size();
+        DescriptorSetLayout.LayoutInformation[] descSetLayouts = new DescriptorSetLayout.LayoutInformation[numAttachments];
+        for (int i = 0; i < numAttachments; i++) {
+            descSetLayouts[i] = new DescriptorSetLayout.LayoutInformation(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, i, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
+        }
+        AttachmentDescriptorSetLayout = new DescriptorSetLayout(VkCtx, descSetLayouts);
+
+        CreateAttachmentDescriptorSet(VkCtx, AttachmentDescriptorSetLayout, attachments, textureSampler);
+
+        pipeline = createPipeline(VkCtx, shaderModules, new DescriptorSetLayout[]{AttachmentDescriptorSetLayout});
+        Arrays.asList(shaderModules).forEach(s -> s.CleanUp(VkCtx));
+    }
+
+    private static void CreateAttachmentDescriptorSet(VulkanContext VkCtx, DescriptorSetLayout descSetLayout, List<Attachment> attachments,
+                                         TextureSampler sampler) {
+        DescriptorAllocator descAllocator = VkCtx.GetDescriptorAllocator();
+        Device device = VkCtx.GetDevice();
+        DescriptorSet descSet = descAllocator.AddDescriptorSet(device, DESC_ID_ATT, descSetLayout);
+        List<ImageView> imageViews = new ArrayList<>();
+        attachments.forEach(a -> imageViews.add(a.GetVkImageView()));
+        descSet.SetImages(device, imageViews, sampler, 0);
+    }
+
+    private static Attachment CreateColourAttachment(VulkanContext VkCtx) {
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        VkExtent2D swapChainExtent = swapChain.GetSwapChainExtent();
+        return new Attachment(VkCtx, swapChainExtent.width(), swapChainExtent.height(),
+                COLOUR_FORMAT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+    }
+
+    private static VkRenderingAttachmentInfo.Buffer CreateColourAttachmentInfo(Attachment attachment, VkClearValue clearValue) {
+        return VkRenderingAttachmentInfo.calloc(1)
+                .sType$Default()
+                .imageView(attachment.GetVkImageView().GetVulkanImageView())
+                .imageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
+                .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
+                .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
+                .clearValue(clearValue);
+    }
+
+    private static Pipeline createPipeline(VulkanContext VkCtx, ShaderModule[] shaderModules, DescriptorSetLayout[] descSetLayouts) {
+        var vtxBuffStruct = new EmptyVertexBufferStruct();
+        var buildInfo = new PipelineBuildInfo(shaderModules, vtxBuffStruct.GetVertexInput(), COLOUR_FORMAT)
+                .SetDescriptorSetLayouts(descSetLayouts)
+                .BlendingIsUsed(true);
+        var pipeline = new DefaultPipeline(VkCtx, buildInfo);
+        vtxBuffStruct.CleanUp();
+        return pipeline;
+    }
+
+    private static VkRenderingInfo CreateRenderInfo(Attachment ColourAttachment, VkRenderingAttachmentInfo.Buffer ColourAttachmentInfo) {
+        VkRenderingInfo result;
+        try (var stack = MemoryStack.stackPush()) {
+            VkExtent2D extent = VkExtent2D.calloc(stack);
+            extent.width(ColourAttachment.GetVkImage().GetWidth());
+            extent.height(ColourAttachment.GetVkImage().GetHeight());
+            var renderArea = VkRect2D.calloc(stack).extent(extent);
+
+            result = VkRenderingInfo.calloc()
+                    .sType$Default()
+                    .renderArea(renderArea)
+                    .layerCount(1)
+                    .pColorAttachments(ColourAttachmentInfo);
+        }
+        return result;
+    }
+
+    private static ShaderModule[] CreateShaderModules(VulkanContext VkCtx) {
+        if (EngineConfig.getInstance().RecompileShaders()) {
+            ShaderCompiler.CompileGLSLShaderOnChange(VERTEX_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_vertex_shader);
+            ShaderCompiler.CompileGLSLShaderOnChange(FRAGMENT_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_fragment_shader);
+        }
+        return new ShaderModule[]{
+                new ShaderModule(VkCtx, VK_SHADER_STAGE_VERTEX_BIT, VERTEX_SHADER_FILE_SPV, null),
+                new ShaderModule(VkCtx, VK_SHADER_STAGE_FRAGMENT_BIT, FRAGMENT_SHADER_FILE_SPV, null),
+        };
+    }
+
+
+    public void render(VulkanContext VkCtx, CommandBuffer cmdBuffer, MultiRenderTargetAttachments mrtAttachments) {
+        try (var stack = MemoryStack.stackPush()) {
+            VkCommandBuffer cmdHandle = cmdBuffer.GetVulkanCommandBuffer();
+
+            VulkanUtils.ImageBarrier(stack, cmdHandle, AttachmentColour.GetVkImage().getVulkanImage(),
+                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                    VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
+                    VK_ACCESS_2_NONE, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
+                    VK_IMAGE_ASPECT_COLOR_BIT);
+
+            List<Attachment> attachments = mrtAttachments.GetColourAttachments();
+            int numAttachments = attachments.size();
+            for (int i = 0; i < numAttachments; i++) {
+                Attachment attachment = attachments.get(i);
+                VulkanUtils.ImageBarrier(stack, cmdHandle, attachment.GetVkImage().getVulkanImage(),
+                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                        VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+                        VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_SHADER_READ_BIT,
+                        VK_IMAGE_ASPECT_COLOR_BIT);
+            }
+            VulkanUtils.ImageBarrier(stack, cmdHandle, mrtAttachments.GetDepthAttachment().GetVkImage().getVulkanImage(),
+                    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                    VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,
+                    VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_SHADER_READ_BIT,
+                    VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
+
+            vkCmdBeginRendering(cmdHandle, RenderInfo);
+
+            vkCmdBindPipeline(cmdHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.GetVulkanPipeline());
+
+            Image ColourImage = AttachmentColour.GetVkImage();
+            int width = ColourImage.GetWidth();
+            int height = ColourImage.GetHeight();
+            var viewport = VkViewport.calloc(1, stack)
+                    .x(0)
+                    .y(height)
+                    .height(-height)
+                    .width(width)
+                    .minDepth(0.0f)
+                    .maxDepth(1.0f);
+            vkCmdSetViewport(cmdHandle, 0, viewport);
+
+            var scissor = VkRect2D.calloc(1, stack)
+                    .extent(it -> it.width(width).height(height))
+                    .offset(it -> it.x(0).y(0));
+            vkCmdSetScissor(cmdHandle, 0, scissor);
+
+            DescriptorAllocator descAllocator = VkCtx.GetDescriptorAllocator();
+            LongBuffer descriptorSets = stack.mallocLong(1)
+                    .put(0, descAllocator.GetDescriptorSet(DESC_ID_ATT).GetVkDescriptorSet());
+            vkCmdBindDescriptorSets(cmdHandle, VK_PIPELINE_BIND_POINT_GRAPHICS,
+                    pipeline.GetVulkanPipelineLayout(), 0, descriptorSets, null);
+
+            vkCmdDraw(cmdHandle, 3, 1, 0, 0);
+
+            vkCmdEndRendering(cmdHandle);
+        }
+    }
+
+    public void resize(VulkanContext VkCtx, List<Attachment> attachments) {
+        RenderInfo.free();
+        AttachmentInfoColour.free();
+        AttachmentColour.CleanUp(VkCtx);
+
+        AttachmentColour = CreateColourAttachment(VkCtx);
+        AttachmentInfoColour = CreateColourAttachmentInfo(AttachmentColour, ClearValueColour);
+        RenderInfo = CreateRenderInfo(AttachmentColour, AttachmentInfoColour);
+
+        DescriptorSet descSet = VkCtx.GetDescriptorAllocator().GetDescriptorSet(DESC_ID_ATT);
+        var imageViews = new ArrayList<ImageView>();
+        attachments.forEach(a -> imageViews.add(a.GetVkImageView()));
+        descSet.SetImages(VkCtx.GetDevice(), imageViews, textureSampler, 0);
+    }
+
+    public void cleanup(VulkanContext VkCtx) {
+        pipeline.CleanUp(VkCtx);
+        AttachmentDescriptorSetLayout.CleanUp(VkCtx);
+        textureSampler.CleanUp(VkCtx);
+        RenderInfo.free();
+        AttachmentColour.CleanUp(VkCtx);
+        AttachmentInfoColour.free();
+        ClearValueColour.free();
+    }
+
+    public Attachment getAttachment() {
+        return AttachmentColour;
+    }
+}

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/DeferredRendering/MultiRenderTargetAttachments.java

@@ -1,4 +1,4 @@
-package net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Deferred;
+package net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering;
 
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
@@ -7,9 +7,9 @@ import org.lwjgl.vulkan.VkExtent2D;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.lwjgl.vulkan.VK13.*;
+import static org.lwjgl.vulkan.VK10.*;
+import static org.lwjgl.vulkan.VK10.VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
-//multiple render target attachments
 public class MultiRenderTargetAttachments {
     public static final int ALBEDO_FORMAT = VK_FORMAT_R16G16B16A16_SFLOAT;
     public static final int DEPTH_FORMAT = VK_FORMAT_D32_SFLOAT_S8_UINT;

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/Pipeline/DefaultPipeline.java

@@ -88,7 +88,7 @@ public class DefaultPipeline implements Pipeline {
             if(BuildInfo.GetDepthFormat() != VK_FORMAT_UNDEFINED){
                 DepthStencil = VkPipelineDepthStencilStateCreateInfo.calloc(MemStack)
                         .sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO)
-                        .depthTestEnable(BuildInfo.performDepthTest())
+                        .depthTestEnable(true)
                         .depthWriteEnable(BuildInfo.performDepthWrite())
                         .depthCompareOp(VK_COMPARE_OP_GREATER_OR_EQUAL)
                         .depthBoundsTestEnable(false)

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/Pipeline/Images/Attachment.java

@@ -12,7 +12,7 @@ public class Attachment {
     private boolean DepthAttachment;
 
     public Attachment(VulkanContext VkCtx, int Width, int Height, int Format, int Usage){
-        var ImageData = new Image.ImageData().Width(Width).Height(Height).Format(Format).MemoryUsage(VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT).SampleCount(EngineConfig.getInstance().GetRenderSampleCount());
+        var ImageData = new Image.ImageData().Width(Width).Height(Height).Format(Format).SampleCount(EngineConfig.getInstance().GetRenderSampleCount());
 
         int AspectMask = 0;
         if((Usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) > 0){

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/Pipeline/Images/TextureCache.java

@@ -18,7 +18,7 @@ import java.util.UUID;
 import static org.lwjgl.vulkan.VK10.VK_FORMAT_R8G8B8A8_SRGB;
 
 public class TextureCache {
-    public static final int MAX_TEXTURES = 500;
+    public static final int MAX_TEXTURES = 64;
     private final IndexedLinkedHashMap<String, Texture> TextureMap;
     private final List<String> ActualTextures;
 

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/Pipeline/PipelineBuildInfo.java

@@ -17,7 +17,6 @@ public class PipelineBuildInfo {
     private DescriptorSetLayout[] DescriptorSetLayouts;
     private boolean useBlend;
     private boolean DepthWrite = true;
-    private boolean DepthTest = true;
     private boolean DualPass = false;
     private boolean alphaToCoverage = false;
 
@@ -37,14 +36,6 @@ public class PipelineBuildInfo {
         this.DualPass = DualPass;
         return this;
     }
-
-    public PipelineBuildInfo SetDepthTest(boolean DepthTest){
-        this.DepthTest = DepthTest;
-        return this;
-    }
-
-    public boolean performDepthTest(){return DepthTest;}
-
     public PipelineBuildInfo SetDepthWrite(boolean DepthWrite){
         this.DepthWrite = DepthWrite;
         return this;

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Rendering/PostProcessing/PostProcess.java

@@ -116,12 +116,10 @@ public class PostProcess {
     }
 
     private static void CreateAttachmentDescriptorSet(VulkanContext VkCtx, DescriptorSetLayout descriptorSetLayout, Attachment attachment, TextureSampler textureSampler){
-        if(!EngineConfig.getInstance().DeferredRendering() && attachment != null) {
+        DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
-            DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
+        Device device = VkCtx.GetDevice();
-            Device device = VkCtx.GetDevice();
+        DescriptorSet descriptorSet = descriptorAllocator.AddDescriptorSets(device,DESCRIPTOR_ID_ATTACHMENT,1 , descriptorSetLayout)[0];
-            DescriptorSet descriptorSet = descriptorAllocator.AddDescriptorSets(device, DESCRIPTOR_ID_ATTACHMENT, 1, descriptorSetLayout)[0];
+        descriptorSet.SetImage(device,attachment.GetVkImageView(),textureSampler,0);
-            descriptorSet.SetImage(device, attachment.GetVkImageView(), textureSampler, 0);
-        }
     }
 
     private static ShaderModule[] CreateShaderModules(VulkanContext VkCtx, SpecializationConstants specConstants){
@@ -140,47 +138,43 @@ public class PostProcess {
     }
 
     public void Render(VulkanContext VkCtx, CommandBuffer commandBuffer, Attachment SrcAttachment){
-        if(SrcAttachment != null) {
+        try(var MemStack = MemoryStack.stackPush()){
-            try (var MemStack = MemoryStack.stackPush()) {
+            SwapChain swapChain = VkCtx.GetSwapChain();
-                SwapChain swapChain = VkCtx.GetSwapChain();
+            VkCommandBuffer CommandHandle = commandBuffer.GetVulkanCommandBuffer();
-                VkCommandBuffer CommandHandle = commandBuffer.GetVulkanCommandBuffer();
 
-                VulkanUtils.ImageBarrier(MemStack, CommandHandle, SrcAttachment.GetVkImage().getVulkanImage(),
+            VulkanUtils.ImageBarrier(MemStack, CommandHandle, SrcAttachment.GetVkImage().getVulkanImage(),
-                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
+                    VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
-                        VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_SHADER_READ_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+                    VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT,VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,VK_ACCESS_2_SHADER_READ_BIT,VK_IMAGE_ASPECT_COLOR_BIT);
-                VulkanUtils.ImageBarrier(MemStack, CommandHandle, ColourAttachment.GetVkImage().getVulkanImage(),
+            VulkanUtils.ImageBarrier(MemStack,CommandHandle,ColourAttachment.GetVkImage().getVulkanImage(),
-                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
+                    VK_IMAGE_LAYOUT_UNDEFINED,VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT,VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
-                        VK_ACCESS_2_NONE, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, VK_IMAGE_ASPECT_COLOR_BIT);
+                    VK_ACCESS_2_NONE,VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,VK_IMAGE_ASPECT_COLOR_BIT);
-                vkCmdBeginRendering(CommandHandle, RenderingInfo);
+            vkCmdBeginRendering(CommandHandle,RenderingInfo);
-                vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.GetVulkanPipeline());
+            vkCmdBindPipeline(CommandHandle,VK_PIPELINE_BIND_POINT_GRAPHICS,pipeline.GetVulkanPipeline());
 
-                VkExtent2D SwapChainExtent = swapChain.GetSwapChainExtent();
+            VkExtent2D SwapChainExtent = swapChain.GetSwapChainExtent();
-                int Width = SwapChainExtent.width();
+            int Width = SwapChainExtent.width();
-                int Height = SwapChainExtent.height();
+            int Height = SwapChainExtent.height();
-                var Viewport = VkViewport.calloc(1, MemStack)
+            var Viewport = VkViewport.calloc(1,MemStack)
-                        .x(0)
+                    .x(0)
-                        .y(Height)
+                    .y(Height)
-                        .height(-Height)
+                    .height(-Height)
-                        .width(Width)
+                    .width(Width)
-                        .minDepth(0.0f)
+                    .minDepth(0.0f)
-                        .maxDepth(1.0f);
+                    .maxDepth(1.0f);
-                vkCmdSetViewport(CommandHandle, 0, Viewport);
+            vkCmdSetViewport(CommandHandle,0,Viewport);
 
-                var Scissor = VkRect2D.calloc(1, MemStack)
+            var Scissor = VkRect2D.calloc(1,MemStack)
-                        .extent(it -> it.width(Width).height(Height))
+                    .extent(it->it.width(Width).height(Height))
-                        .offset(it -> it.x(0).y(0));
+                    .offset(it->it.x(0).y(0));
-                vkCmdSetScissor(CommandHandle, 0, Scissor);
+            vkCmdSetScissor(CommandHandle,0,Scissor);
 
-                DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
+            DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
-                if(descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_ATTACHMENT) != null && descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_SCREEN_SIZE) != null) {
+            LongBuffer DescriptorSets = MemStack.mallocLong(2)
-                    LongBuffer DescriptorSets = MemStack.mallocLong(2)
+                    .put(0,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_ATTACHMENT).GetVkDescriptorSet())
-                            .put(0, descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_ATTACHMENT).GetVkDescriptorSet())
+                    .put(1,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_SCREEN_SIZE).GetVkDescriptorSet());
-                            .put(1, descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_SCREEN_SIZE).GetVkDescriptorSet());
+            vkCmdBindDescriptorSets(CommandHandle,VK_PIPELINE_BIND_POINT_GRAPHICS,pipeline.GetVulkanPipelineLayout(),0,DescriptorSets,null);
-                    vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.GetVulkanPipelineLayout(), 0, DescriptorSets, null);
+            vkCmdDraw(CommandHandle,3,1,0,0);
-                    vkCmdDraw(CommandHandle, 3, 1, 0, 0);
+            vkCmdEndRendering(CommandHandle);
-                }
-                vkCmdEndRendering(CommandHandle);
-            }
         }
     }
 

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Structure/DisplayToScreen/DeferredSceneRender.java

@@ -0,0 +1,430 @@
+package net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen;
+
+import net.halbear.Terrain4J.EngineCore.Logic.EngineConfig;
+import net.halbear.Terrain4J.EngineCore.Logic.EngineInstance;
+import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
+import net.halbear.Terrain4J.EngineCore.Main.PrimaryRuntime;
+import net.halbear.Terrain4J.EngineCore.Main.Scene.Actor;
+import net.halbear.Terrain4J.EngineCore.Main.Scene.Scene;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering.MultiRenderTargetAttachments;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.DefaultPipeline;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Texture;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.TextureCache;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Pipeline;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.PipelineBuildInfo;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.PushConstantsRange;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Shader.*;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VertexBufferStructure;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.VkModel.*;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.CommandBuffer;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DeviceLayers.Device;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Structure.SwapChain.SwapChain;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Util.VulkanBuffer;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Util.VulkanUtils;
+import org.joml.Matrix4f;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.system.MemoryUtil;
+import org.lwjgl.util.shaderc.Shaderc;
+import org.lwjgl.vulkan.*;
+import org.tinylog.Logger;
+
+import java.nio.ByteBuffer;
+import java.nio.LongBuffer;
+import java.util.*;
+
+import static org.lwjgl.vulkan.VK13.*;
+
+public class DeferredSceneRender implements SceneRenderer {//dynamic rendering
+
+    private static final String DESCRIPTOR_ID_MAT = "SCN_DESC_ID_MAT";
+    private static final String DESCRIPTOR_ID_PRJ = "SCN_DESC_ID_PRJ";
+    private static final String DESCRIPTOR_ID_TEXT = "SCN_DESC_ID_TEXT";
+    private static final String DESCRIPTOR_ID_VIEW = "SCN_DESC_ID_VIEW";
+    private static final int PUSH_CONSTANTS_SIZE = VulkanUtils.MATRIX4X4_SIZE + VulkanUtils.INT_SIZE;
+    private final VulkanBuffer BufferProjectionMatrix;
+    private final DescriptorSetLayout descriptorLayoutFragStorage;
+    private final DescriptorSetLayout descriptorLayoutTexture;
+    private final DescriptorSetLayout descriptorLayoutVertexUniform;
+    private final TextureSampler textureSampler;
+
+    private static final int COLOUR_FORMAT = VK_FORMAT_R16G16B16A16_SFLOAT;
+    private static final int DEPTH_FORMAT = VK_FORMAT_D32_SFLOAT_S8_UINT;
+    private final VkClearValue ClearValueDepth;
+    private final ByteBuffer PushConstBuffer;
+    private VkRenderingAttachmentInfo AttachmentInfoDepth;
+    private VkClearValue ClearValueColour;
+    private VkRenderingAttachmentInfo.Buffer AttachmentInfoColour;
+    private VkRenderingInfo RenderInfo;
+    public int Frames = 0;
+    private static String LastGPULog = "";
+    public static long GPUTIME = 0;
+    public static long CYCLES = 0;
+    private static boolean DualPassRendering = false;
+
+    private static final String FRAGMENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/scene_fragment.glsl";
+    private static final String FRAGMENT_TRANSLUCENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/scene_translucent_fragment.glsl";
+    private static final String FRAGMENT_OPAQUE_SHADER_FILE_GLSL = "resources/EngineResources/shaders/scene_opaque_fragment.glsl";
+    private static final String FRAGMENT_SHADER_FILE_SPV  = FRAGMENT_SHADER_FILE_GLSL + ".spv";
+    private static final String FRAGMENT_TRANSLUCENT_SHADER_FILE_SPV  = FRAGMENT_TRANSLUCENT_SHADER_FILE_GLSL + ".spv";
+    private static final String FRAGMENT_OPAQUE_SHADER_FILE_SPV  = FRAGMENT_OPAQUE_SHADER_FILE_GLSL + ".spv";
+    private static final String VERTEX_SHADER_FILE_GLSL  = "resources/EngineResources/shaders/scene_vertex.glsl";
+    private static final String VERTEX_SHADER_FILE_SPV  = VERTEX_SHADER_FILE_GLSL + ".spv";
+    private final VulkanBuffer[] BufferViewMatrices;
+    private Pipeline VkPipeline;
+    private Pipeline VkPipelineOpaque;
+    private Pipeline VkPipelineTranslucent;
+    private float R = 0.5f;
+    private float G = 0.75f;
+    private float B = 1.0f;
+    private Matrix4f ProjectionMatrix;
+    private MultiRenderTargetAttachments MRTAttachments;
+
+    public static long GetGPUTimeNS(){
+        long time = 0;
+        if(CYCLES > 0){
+            time = GPUTIME/CYCLES;
+        }
+        GPUTIME = 0;
+        CYCLES = 0;
+        return time;
+    }
+
+    public DeferredSceneRender(VulkanContext vulkanContext){
+        ClearValueColour = VkClearValue.calloc().color(
+                c -> c.float32(0, R).float32(1, G).float32(2, B).float32(3, 1.0f));
+        ClearValueDepth = VkClearValue.calloc().color(c -> c.float32(0, 0.0f));
+        MRTAttachments = new MultiRenderTargetAttachments(vulkanContext);
+        AttachmentInfoDepth = CreateDepthAttachmentInfo(MRTAttachments, ClearValueDepth);
+        AttachmentInfoColour = CreateColourAttachmentInfo(MRTAttachments,ClearValueColour);
+        RenderInfo = CreateRenderInfo(vulkanContext, AttachmentInfoColour, AttachmentInfoDepth);
+
+        PushConstBuffer = (MemoryUtil.memAlloc(PUSH_CONSTANTS_SIZE));
+
+        descriptorLayoutVertexUniform = new DescriptorSetLayout(vulkanContext, new DescriptorSetLayout.LayoutInformation(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+                0,1,VK_SHADER_STAGE_VERTEX_BIT));
+        BufferProjectionMatrix = VulkanUtils.CreateHostVisibleBuffer(vulkanContext, VulkanUtils.MATRIX4X4_SIZE,
+                VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, DESCRIPTOR_ID_PRJ, descriptorLayoutVertexUniform);
+        ProjectionMatrix = PrimaryRuntime.GetEngineInstance().scene().GetProjection().GetProjectionMatrix();
+        VulkanUtils.CopyMatrixToBuffer(vulkanContext, BufferProjectionMatrix, PrimaryRuntime.GetEngineInstance().scene().GetProjection().GetProjectionMatrix(),0);
+        descriptorLayoutFragStorage = new DescriptorSetLayout(vulkanContext, new DescriptorSetLayout.LayoutInformation(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
+                0,1,VK_SHADER_STAGE_FRAGMENT_BIT));
+        var textureSamplerInfo = new TextureSamplerInfo(VK_SAMPLER_ADDRESS_MODE_REPEAT,
+                VK_BORDER_COLOR_INT_OPAQUE_BLACK,1,true);
+        textureSampler = new TextureSampler(vulkanContext,textureSamplerInfo);
+        descriptorLayoutTexture = new DescriptorSetLayout(vulkanContext, new DescriptorSetLayout.LayoutInformation(
+                VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, TextureCache.MAX_TEXTURES, VK_SHADER_STAGE_FRAGMENT_BIT
+        ));
+        BufferViewMatrices = VulkanUtils.CreateHostVisibleBuffers(vulkanContext, VulkanUtils.MATRIX4X4_SIZE, VulkanUtils.MAX_IN_FLIGHT, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, DESCRIPTOR_ID_VIEW, descriptorLayoutVertexUniform);
+        CreatePipelines(vulkanContext);
+    }
+
+    public void CreatePipelines(VulkanContext vulkanContext){
+        DescriptorSetLayout[] layouts = new DescriptorSetLayout[]{
+                descriptorLayoutVertexUniform,
+                descriptorLayoutVertexUniform,
+                descriptorLayoutFragStorage,
+                descriptorLayoutTexture
+        };
+
+        ShaderModule[] shaderModules = DeferredSceneRender.CreateShaderModules(vulkanContext,0);
+        VkPipeline = CreatePipeline(vulkanContext, shaderModules, layouts, true, false,EngineConfig.getInstance().AlphaToCoverage());
+        shaderModules = DeferredSceneRender.CreateShaderModules(vulkanContext,1);
+        VkPipelineOpaque = CreatePipeline(vulkanContext, shaderModules, layouts, true, true,EngineConfig.getInstance().AlphaToCoverage());
+        shaderModules = DeferredSceneRender.CreateShaderModules(vulkanContext,2);
+        VkPipelineTranslucent = CreatePipeline(vulkanContext, shaderModules, layouts, false, true,EngineConfig.getInstance().AlphaToCoverage());
+        Arrays.asList(shaderModules).forEach(shaderModule -> shaderModule.CleanUp(vulkanContext));
+    }
+
+    public void RebuildPipelines(VulkanContext vulkanContext){
+        CreatePipelines(vulkanContext);
+    }
+
+    public static void SetDualPassRendering(boolean dualPass){
+        DualPassRendering = dualPass;
+    }
+
+    public static boolean DualPassRendering(){return DualPassRendering;}
+
+    private static Attachment CreateColourAttachment(VulkanContext VkCtx){
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        VkExtent2D SwapChainExtent = swapChain.GetSwapChainExtent();
+        return new Attachment(VkCtx, SwapChainExtent.width(), SwapChainExtent.height(), COLOUR_FORMAT,VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
+    }
+
+    private static VkRenderingAttachmentInfo.Buffer CreateColourAttachmentInfo(MultiRenderTargetAttachments attachment, VkClearValue ClearValue){
+        List<Attachment> attachments = attachment.GetColourAttachments();
+        int numAttachments = attachments.size();
+        VkRenderingAttachmentInfo.Buffer result = VkRenderingAttachmentInfo.calloc(numAttachments);
+        for (int i = 0; i < numAttachments; ++i) {
+            result.get(i)
+                    .sType$Default()
+                    .imageView(attachments.get(i).GetVkImageView().GetVulkanImageView())
+                    .imageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
+                    .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
+                    .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
+                    .clearValue(ClearValue);
+        }
+        return result;
+    }
+
+    private static Attachment CreateDepthAttachment(VulkanContext VkCtx){
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        VkExtent2D swapChainExtent = swapChain.GetSwapChainExtent();
+        return new Attachment(VkCtx, swapChainExtent.width(), swapChainExtent.height(),
+                DEPTH_FORMAT,VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
+    }
+
+
+    private static VkRenderingAttachmentInfo CreateDepthAttachmentInfo(MultiRenderTargetAttachments DepthAttachment, VkClearValue clearValue){
+        return VkRenderingAttachmentInfo.calloc()
+                .sType$Default()
+                .imageView(DepthAttachment.GetDepthAttachment().GetVkImageView().GetVulkanImageView())
+                .imageLayout(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
+                .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
+                .storeOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
+                .clearValue(clearValue);
+    }
+
+    private static Attachment[] createDepthAttachments(VulkanContext VkCtx){
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        int ImageCount = swapChain.GetImageCount();
+        VkExtent2D swapChainExtent = swapChain.GetSwapChainExtent();
+        Attachment[] DepthAttachments = new Attachment[ImageCount];
+        for(int i = 0; i < ImageCount; i++){
+            DepthAttachments[i] = new Attachment(VkCtx, swapChainExtent.width(), swapChainExtent.height(),
+                    DEPTH_FORMAT,VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT);
+        }
+        return DepthAttachments;
+    }
+
+    private static VkRenderingAttachmentInfo[] createDepthAttachmentsInfo(VulkanContext VkCtx, Attachment[] DepthAttachments, VkClearValue clearValue){
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        int ImageCount = swapChain.GetImageCount();
+        var Result = new VkRenderingAttachmentInfo[ImageCount];
+        for(int i = 0; i < ImageCount; i++){
+            var Attachments = VkRenderingAttachmentInfo.calloc()
+                    .sType$Default()
+                    .imageView(DepthAttachments[i].GetVkImageView().GetVulkanImageView())
+                    .imageLayout(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
+                    .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
+                    .storeOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
+                    .clearValue(clearValue);
+            Result[i] = Attachments;
+        }
+        return Result;
+    }
+
+    private static ShaderModule[] CreateShaderModules(VulkanContext VkCtx, int Translucent){
+        if(EngineConfig.getInstance().RecompileShaders()){
+            ShaderCompiler.CompileGLSLShaderOnChange(VERTEX_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_vertex_shader);
+            ShaderCompiler.CompileGLSLShaderOnChange( Translucent == 2 ? FRAGMENT_TRANSLUCENT_SHADER_FILE_GLSL : Translucent == 1 ? FRAGMENT_OPAQUE_SHADER_FILE_GLSL : FRAGMENT_SHADER_FILE_GLSL, Shaderc.shaderc_glsl_fragment_shader);
+        }
+        return new ShaderModule[]{
+                new ShaderModule(VkCtx, VK_SHADER_STAGE_VERTEX_BIT, VERTEX_SHADER_FILE_SPV,null),
+                new ShaderModule(VkCtx, VK_SHADER_STAGE_FRAGMENT_BIT, Translucent == 2 ? FRAGMENT_TRANSLUCENT_SHADER_FILE_SPV : Translucent == 1 ? FRAGMENT_OPAQUE_SHADER_FILE_SPV : FRAGMENT_SHADER_FILE_SPV,null)
+        };
+    }
+
+    private static Pipeline CreatePipeline(VulkanContext VkCtx, ShaderModule[] ShaderModules, DescriptorSetLayout[] DescriptorSetLayouts, boolean DepthWrite, boolean DualRender, boolean AlphaToCoverage){
+        var vertexBufferStructure = new VertexBufferStructure();
+        var BuildInfo = new PipelineBuildInfo(ShaderModules,vertexBufferStructure.getVertexInput(),MultiRenderTargetAttachments.ALBEDO_FORMAT)
+                .SetDepthFormat(MultiRenderTargetAttachments.DEPTH_FORMAT)
+                .SetDepthWrite(DepthWrite)
+                .SetPushConstantRanges(
+                         new PushConstantsRange[]{
+                                new PushConstantsRange(VK_SHADER_STAGE_VERTEX_BIT,0,VulkanUtils.MATRIX4X4_SIZE),
+                                new PushConstantsRange(VK_SHADER_STAGE_FRAGMENT_BIT,VulkanUtils.MATRIX4X4_SIZE,VulkanUtils.INT_SIZE)
+                        })
+                .SetDescriptorSetLayouts(DescriptorSetLayouts)
+                .BlendingIsUsed(DualRender ? !DepthWrite : true)
+                .SetDualPass(DualRender)
+                .SetAlphaToCoverage(AlphaToCoverage);
+        var pipeline = new DefaultPipeline(VkCtx, BuildInfo);
+        vertexBufferStructure.cleanup();
+        return pipeline;
+    }
+
+
+    public void Render(EngineInstance engineInstance,VulkanContext vulkanContext, CommandBuffer commandBuffer, ModelsCache modelsCache,MaterialsCache materialsCache, int CurrentFrame){
+        try(var MemStack = MemoryStack.stackPush()){
+            VkCommandBuffer CommandHandle = commandBuffer.GetVulkanCommandBuffer();
+
+            List<Attachment> attachments = MRTAttachments.GetColourAttachments();
+            int AttachmentCount = attachments.size();
+            for (int i = 0; i < AttachmentCount; i++) {
+                Attachment attachment = attachments.get(i);
+                VulkanUtils.ImageBarrier(MemStack, CommandHandle, attachment.GetVkImage().getVulkanImage(),
+                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+                        VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
+                        VK_ACCESS_NONE, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
+                        VK_IMAGE_ASPECT_COLOR_BIT);
+            }
+            VulkanUtils.ImageBarrier(MemStack, CommandHandle, MRTAttachments.GetDepthAttachment().GetVkImage().getVulkanImage(),
+                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
+                    VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
+                    VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
+                    VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
+                    VK_IMAGE_ASPECT_DEPTH_BIT);
+
+            long InitialTime = System.nanoTime();
+            vkCmdBeginRendering(CommandHandle, RenderInfo);
+
+            vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, DualPassRendering ? VkPipelineOpaque.GetVulkanPipeline() : VkPipeline.GetVulkanPipeline());
+
+            int width = MRTAttachments.GetWidth();
+            int height = MRTAttachments.GetHeight();
+            var Viewport = VkViewport.calloc(1,MemStack)
+                            .x(0)
+                            .y(height)
+                            .height(-height)
+                            .width(width)
+                            .minDepth(0.0F)
+                            .maxDepth(1.0F);
+            vkCmdSetViewport(CommandHandle, 0, Viewport);
+            var Scissor = VkRect2D.calloc(1,MemStack)
+                            .extent(it -> it.width(width).height(height))
+                            .offset(it->it.x(0).y(0));
+            vkCmdSetScissor(CommandHandle, 0, Scissor);
+
+            VulkanUtils.CopyMatrixToBuffer(vulkanContext, BufferViewMatrices[CurrentFrame],engineInstance.scene().GetCamera().GetViewMatrix(), 0); // here
+            DescriptorAllocator descriptorAllocator = vulkanContext.GetDescriptorAllocator();
+            LongBuffer DescriptorSets = MemStack.mallocLong(4)
+                    .put(0,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_PRJ).GetVkDescriptorSet())
+                    .put(1,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_VIEW, CurrentFrame).GetVkDescriptorSet())
+                    .put(2,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_MAT).GetVkDescriptorSet())
+                    .put(3,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_TEXT).GetVkDescriptorSet());
+            vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, DualPassRendering ? VkPipelineOpaque.GetVulkanPipelineLayout() : VkPipeline.GetVulkanPipelineLayout(),0,DescriptorSets,null);
+
+            RenderActors(engineInstance, CommandHandle, modelsCache, materialsCache, false);
+            if(DualPassRendering) {
+                vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, VkPipelineTranslucent.GetVulkanPipeline());
+                vkCmdSetViewport(CommandHandle, 0, Viewport);
+                vkCmdSetScissor(CommandHandle, 0, Scissor);
+                vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, VkPipelineTranslucent.GetVulkanPipelineLayout(), 0, DescriptorSets, null);
+            }
+            RenderActors(engineInstance, CommandHandle, modelsCache, materialsCache, true);
+
+            vkCmdEndRendering(CommandHandle);
+            GPUTIME += System.nanoTime() - InitialTime;
+            CYCLES++;
+        }
+    }
+
+    private void RenderActors(EngineInstance instance, VkCommandBuffer CommandHandle, ModelsCache modelsCache, MaterialsCache materialsCache, boolean Transparent){
+        try(var MemStack = MemoryStack.stackPush()){
+            LongBuffer offsets = MemStack.mallocLong(1).put(0,0L);
+            LongBuffer vertexBuffer = MemStack.mallocLong(1);
+            Scene scene = instance.scene();
+            List<Actor> Actors = scene.GetActors();
+            int ActorCount = Actors.size();
+            List<Actor> translucentObjects = new ArrayList<>();
+            for(int i = 0; i < ActorCount; i++){
+                if(i < Actors.size()) {
+                    var Actor = Actors.get(i);
+                    if(Actor != null) {
+                        VulkanModel model = modelsCache.GetModel(Actor.GetModelID());
+                        List<VulkanMesh> VkMeshList = model.GetVkMeshList();
+                        int MeshCount = VkMeshList.size();
+                        for (int j = 0; j < MeshCount; j++) {
+                            var VkMesh = VkMeshList.get(j);
+                            String MaterialID = VkMesh.MaterialID();
+                            int MaterialIndex = materialsCache.GetPosition(MaterialID);
+                            VulkanMaterial vulkanMaterial = materialsCache.GetMaterial(MaterialID);
+                            if (vulkanMaterial == null) {
+                                Logger.warn("Mesh [{}] in model [{}] does not have material", j, model.GetID());
+                                continue;
+                            }
+                            if (DualPassRendering || vulkanMaterial.HasTransparency() == Transparent) {
+                                SetPushConstants(CommandHandle, Actor.GetModelMatrix(), MaterialIndex);
+                                vertexBuffer.put(0, VkMesh.VerticesBuffer().GetBuffer());
+                                vkCmdBindVertexBuffers(CommandHandle, 0, vertexBuffer, offsets);
+                                vkCmdBindIndexBuffer(CommandHandle, VkMesh.IndicesBuffer().GetBuffer(), 0, VK_INDEX_TYPE_UINT32);
+                                vkCmdDrawIndexed(CommandHandle, VkMesh.IndicesCount(), 1, 0, 0, 0);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void SetPushConstants(VkCommandBuffer CmdHandle, Matrix4f ModelMatrix, int MaterialIndex){
+        ModelMatrix.get(0,PushConstBuffer);
+        PushConstBuffer.putInt(VulkanUtils.MATRIX4X4_SIZE, MaterialIndex);
+        vkCmdPushConstants(CmdHandle, VkPipeline.GetVulkanPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0,
+                PushConstBuffer.slice(0,VulkanUtils.MATRIX4X4_SIZE));
+        vkCmdPushConstants(CmdHandle, VkPipeline.GetVulkanPipelineLayout(), VK_SHADER_STAGE_FRAGMENT_BIT, VulkanUtils.MATRIX4X4_SIZE,
+                PushConstBuffer.slice(VulkanUtils.MATRIX4X4_SIZE, VulkanUtils.INT_SIZE));
+    }
+
+    public void Resize(EngineInstance instance, VulkanContext VkCtx){
+        RenderInfo.free();
+        AttachmentInfoDepth.free();
+        MRTAttachments.CleanUp(VkCtx);
+        Arrays.asList(AttachmentInfoColour).forEach(VkRenderingAttachmentInfo.Buffer::free);
+
+        MRTAttachments = new MultiRenderTargetAttachments(VkCtx);
+        AttachmentInfoColour = CreateColourAttachmentInfo(MRTAttachments, ClearValueColour);
+        AttachmentInfoDepth = CreateDepthAttachmentInfo(MRTAttachments, ClearValueDepth);
+        RenderInfo = CreateRenderInfo(VkCtx, AttachmentInfoColour, AttachmentInfoDepth);
+
+        VulkanUtils.CopyMatrixToBuffer(VkCtx, BufferProjectionMatrix, instance.scene().GetProjection().GetProjectionMatrix(), 0);}
+
+    public void LoadMaterials(VulkanContext VkCtx, MaterialsCache materialsCache, TextureCache textureCache){
+        DescriptorAllocator descriptorAllocator = VkCtx.GetDescriptorAllocator();
+        Device device = VkCtx.GetDevice();
+        DescriptorSet descriptorSet = descriptorAllocator.AddDescriptorSet(device,DESCRIPTOR_ID_MAT,descriptorLayoutFragStorage);
+        DescriptorSetLayout.LayoutInformation LayoutInfo = descriptorLayoutFragStorage.GetLayoutInfo();
+        var Buffer = materialsCache.GetMaterialsBuffer();
+        descriptorSet.SetBuffer(device,Buffer,Buffer.GetRequestedSize(),LayoutInfo.Binding(),LayoutInfo.DescriptorType());
+        List<ImageView> imageViews = textureCache.GetTextureList().stream().map(Texture::GetImageView).toList();
+        descriptorSet = VkCtx.GetDescriptorAllocator().AddDescriptorSet(device,DESCRIPTOR_ID_TEXT,descriptorLayoutTexture);
+        descriptorSet.SetImageArray(device,imageViews,textureSampler,0);
+    }
+
+    private static VkRenderingInfo CreateRenderInfo(VulkanContext VkCtx, VkRenderingAttachmentInfo.Buffer ColourAttachmentInfo, VkRenderingAttachmentInfo DepthAttachmentInfo){
+        VkRenderingInfo Result;
+        SwapChain swapChain = VkCtx.GetSwapChain();
+        VkExtent2D Extent = swapChain.GetSwapChainExtent();
+        try(var MemStack = MemoryStack.stackPush()){
+            var RenderArea = VkRect2D.calloc(MemStack).extent(Extent);
+            Result = VkRenderingInfo.calloc()
+                    .sType$Default()
+                    .renderArea(RenderArea)
+                    .layerCount(1)
+                    .pColorAttachments(ColourAttachmentInfo)
+                    .pDepthAttachment(DepthAttachmentInfo);
+        }
+        return Result;
+    }
+
+    public void cleanup(VulkanContext VkCtx){
+        VkPipeline.CleanUp(VkCtx);
+        VkPipelineOpaque.CleanUp(VkCtx);
+        VkPipelineTranslucent.CleanUp(VkCtx);
+        Arrays.asList(BufferViewMatrices).forEach(b -> b.cleanup(VkCtx));
+        descriptorLayoutTexture.CleanUp(VkCtx);
+        textureSampler.CleanUp(VkCtx);
+        descriptorLayoutFragStorage.CleanUp(VkCtx);
+        BufferProjectionMatrix.cleanup(VkCtx);
+        descriptorLayoutVertexUniform.CleanUp(VkCtx);
+        RenderInfo.free();
+        AttachmentInfoDepth.free();
+        MRTAttachments.CleanUp(VkCtx);
+        AttachmentInfoColour.free();
+        MemoryUtil.memFree(PushConstBuffer);
+        ClearValueDepth.free();
+        ClearValueColour.free();
+    }
+
+    @Override
+    public MultiRenderTargetAttachments GetMRTAttachments() {
+        return MRTAttachments;
+    }
+
+    @Override
+    public Attachment GetAttachmentColour() {
+        return null;
+    }
+}

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Structure/DisplayToScreen/ForwardSceneRender.java

@@ -6,7 +6,7 @@ import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
 import net.halbear.Terrain4J.EngineCore.Main.PrimaryRuntime;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.Actor;
 import net.halbear.Terrain4J.EngineCore.Main.Scene.Scene;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Deferred.MultiRenderTargetAttachments;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering.MultiRenderTargetAttachments;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.DefaultPipeline;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Image;
@@ -32,12 +32,12 @@ import org.tinylog.Logger;
 
 import java.nio.ByteBuffer;
 import java.nio.LongBuffer;
-import java.util.*;
+import java.util.Arrays;
+import java.util.List;
 
-import static org.lwjgl.vulkan.KHRSynchronization2.VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR;
 import static org.lwjgl.vulkan.VK13.*;
 
-public class SceneRender implements SceneRenderer {//dynamic rendering
+public class ForwardSceneRender implements SceneRenderer {//dynamic rendering
 
     private static final String FRAGMENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/scene_fragment.glsl";
     private static final String FRAGMENT_TRANSLUCENT_SHADER_FILE_GLSL = "resources/EngineResources/shaders/scene_translucent_fragment.glsl";
@@ -83,7 +83,6 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
     private Pipeline VkPipelineOpaque;
     private Pipeline VkPipelineTranslucent;
     private Matrix4f ProjectionMatrix;
-    private MultiRenderTargetAttachments MRTAttachments;
     private boolean Deferred = false;
 
     public static long GetGPUTimeNS(){
@@ -96,25 +95,15 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
         return time;
     }
 
-    public boolean GetCurrentDeferred(){return Deferred;}
-
-    public void UpdateDeferred(VulkanContext vulkanContext){
-        Deferred = EngineConfig.getInstance().DeferredRendering();
-        CreateRenderAttachments(vulkanContext);
-        CreatePipelines(vulkanContext);
-    }
-
     public void CreateRenderAttachments(VulkanContext vulkanContext){
-        MRTAttachments = new MultiRenderTargetAttachments(vulkanContext);
         AttachmentColour = CreateColourAttachment(vulkanContext);
         AttachmentDepth = CreateDepthAttachment(vulkanContext);
-        AttachmentInfoDepth = Deferred ? CreateDeferredDepthAttachmentInfo(MRTAttachments, ClearValueDepth) : CreateDepthAttachmentInfo(AttachmentDepth, ClearValueDepth);
+        AttachmentInfoDepth =  CreateDepthAttachmentInfo(AttachmentDepth, ClearValueDepth);
-        AttachmentInfoColour = Deferred ? CreateDeferredColourAttachmentInfo(MRTAttachments, ClearValueDepth) : CreateColourAttachmentInfo(AttachmentColour,ClearValueColour);
+        AttachmentInfoColour =CreateColourAttachmentInfo(AttachmentColour,ClearValueColour);
-        RenderInfo = Deferred ? CreateDeferredRenderInfo(vulkanContext, AttachmentInfoColour, AttachmentInfoDepth) : CreateRenderInfo(AttachmentColour, AttachmentInfoColour, AttachmentInfoDepth);
+        RenderInfo = CreateRenderInfo(AttachmentColour, AttachmentInfoColour, AttachmentInfoDepth);
     }
 
-    public SceneRender(VulkanContext vulkanContext){
+    public ForwardSceneRender(VulkanContext vulkanContext){
-        Deferred = EngineConfig.getInstance().DeferredRendering();
         ClearValueColour = VkClearValue.calloc().color(
                 c -> c.float32(0, R).float32(1, G).float32(2, B).float32(3, 1.0f));
         ClearValueDepth = VkClearValue.calloc().color(c -> c.float32(0, 0.0f));
@@ -149,12 +138,12 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
                 descriptorLayoutTexture
         };
 
-        ShaderModule[] shaderModules = SceneRender.CreateShaderModules(vulkanContext,0);
+        ShaderModule[] shaderModules = CreateShaderModules(vulkanContext,0);
-        VkPipeline = Deferred ? CreateDeferredPipeline(vulkanContext, shaderModules, layouts, true, false,EngineConfig.getInstance().AlphaToCoverage()) : CreatePipeline(vulkanContext, shaderModules, layouts, true, false,EngineConfig.getInstance().AlphaToCoverage());
+        VkPipeline = CreatePipeline(vulkanContext, shaderModules, layouts, true, false,EngineConfig.getInstance().AlphaToCoverage());
-        shaderModules = SceneRender.CreateShaderModules(vulkanContext,1);
+        shaderModules = CreateShaderModules(vulkanContext,1);
-        VkPipelineOpaque = Deferred ? CreateDeferredPipeline(vulkanContext, shaderModules, layouts, true, true,EngineConfig.getInstance().AlphaToCoverage()) : CreatePipeline(vulkanContext, shaderModules, layouts, true, true,EngineConfig.getInstance().AlphaToCoverage());
+        VkPipelineOpaque =  CreatePipeline(vulkanContext, shaderModules, layouts, true, true,EngineConfig.getInstance().AlphaToCoverage());
-        shaderModules = SceneRender.CreateShaderModules(vulkanContext,2);
+        shaderModules = CreateShaderModules(vulkanContext,2);
-        VkPipelineTranslucent = Deferred ? CreateDeferredPipeline(vulkanContext, shaderModules, layouts, false, true,EngineConfig.getInstance().AlphaToCoverage()) : CreatePipeline(vulkanContext, shaderModules, layouts, false, true,EngineConfig.getInstance().AlphaToCoverage());
+        VkPipelineTranslucent =  CreatePipeline(vulkanContext, shaderModules, layouts, false, true,EngineConfig.getInstance().AlphaToCoverage());
         Arrays.asList(shaderModules).forEach(shaderModule -> shaderModule.CleanUp(vulkanContext));
     }
 
@@ -174,21 +163,6 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
         return new Attachment(VkCtx, SwapChainExtent.width(), SwapChainExtent.height(), COLOUR_FORMAT,VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
     }
 
-    private static VkRenderingAttachmentInfo.Buffer CreateDeferredColourAttachmentInfo(MultiRenderTargetAttachments attachment, VkClearValue ClearValue){
-        List<Attachment> colourAttachments = attachment.GetColourAttachments();
-        int AttachmentCount = colourAttachments.size();
-        VkRenderingAttachmentInfo.Buffer result = VkRenderingAttachmentInfo.calloc(AttachmentCount);
-        for(int i = 0; i < AttachmentCount; i++) {
-            result.get(i).sType$Default()
-                    .imageView(attachment.GetColourAttachments().get(i).GetVkImageView().GetVulkanImageView())
-                    .imageLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)
-                    .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
-                    .storeOp(VK_ATTACHMENT_STORE_OP_STORE)
-                    .clearValue(ClearValue);
-        }
-        return result;
-    }
-
 
     private static VkRenderingAttachmentInfo.Buffer CreateColourAttachmentInfo(Attachment attachment, VkClearValue ClearValue){
         return VkRenderingAttachmentInfo.calloc(1)
@@ -208,16 +182,6 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
     }
 
 
-    private static VkRenderingAttachmentInfo CreateDeferredDepthAttachmentInfo(MultiRenderTargetAttachments DepthAttachment, VkClearValue clearValue){
-        return VkRenderingAttachmentInfo.calloc()
-                .sType$Default()
-                .imageView(DepthAttachment.GetDepthAttachment().GetVkImageView().GetVulkanImageView())
-                .imageLayout(VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
-                .loadOp(VK_ATTACHMENT_LOAD_OP_CLEAR)
-                .storeOp(VK_ATTACHMENT_STORE_OP_DONT_CARE)
-                .clearValue(clearValue);
-    }
-
     private static VkRenderingAttachmentInfo CreateDepthAttachmentInfo(Attachment DepthAttachment, VkClearValue clearValue){
         return VkRenderingAttachmentInfo.calloc()
                 .sType$Default()
@@ -240,24 +204,6 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
         };
     }
 
-    private static Pipeline CreateDeferredPipeline(VulkanContext VkCtx, ShaderModule[] ShaderModules, DescriptorSetLayout[] DescriptorSetLayouts, boolean DepthWrite, boolean DualRender, boolean AlphaToCoverage){
-        var vertexBufferStructure = new VertexBufferStructure();
-        var BuildInfo = new PipelineBuildInfo(ShaderModules,vertexBufferStructure.getVertexInput(),MultiRenderTargetAttachments.ALBEDO_FORMAT)
-                .SetDepthFormat(MultiRenderTargetAttachments.DEPTH_FORMAT)
-                .SetDepthWrite(DepthWrite)
-                .SetPushConstantRanges(
-                        new PushConstantsRange[]{
-                                new PushConstantsRange(VK_SHADER_STAGE_VERTEX_BIT,0,VulkanUtils.MATRIX4X4_SIZE),
-                                new PushConstantsRange(VK_SHADER_STAGE_FRAGMENT_BIT,VulkanUtils.MATRIX4X4_SIZE,VulkanUtils.INT_SIZE)
-                        })
-                .SetDescriptorSetLayouts(DescriptorSetLayouts)
-                .BlendingIsUsed(DualRender ? !DepthWrite : true)
-                .SetDualPass(DualRender)
-                .SetAlphaToCoverage(AlphaToCoverage);
-        var pipeline = new DefaultPipeline(VkCtx, BuildInfo);
-        vertexBufferStructure.cleanup();
-        return pipeline;
-    }
 
     private static Pipeline CreatePipeline(VulkanContext VkCtx, ShaderModule[] ShaderModules, DescriptorSetLayout[] DescriptorSetLayouts, boolean DepthWrite, boolean DualRender, boolean AlphaToCoverage){
         var vertexBufferStructure = new VertexBufferStructure();
@@ -322,7 +268,6 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
                     .put(2,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_MAT).GetVkDescriptorSet())
                     .put(3,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_TEXT).GetVkDescriptorSet());
             vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, DualPassRendering ? VkPipelineOpaque.GetVulkanPipelineLayout() : VkPipeline.GetVulkanPipelineLayout(),0,DescriptorSets,null);
-
             RenderActors(engineInstance, CommandHandle, modelsCache, materialsCache, false);
             if(DualPassRendering) {
                 vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, VkPipelineTranslucent.GetVulkanPipeline());
@@ -337,79 +282,10 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
             CYCLES++;
         }
     }
-    public void DeferredRender(EngineInstance engineInstance,VulkanContext vulkanContext, CommandBuffer commandBuffer, ModelsCache modelsCache,MaterialsCache materialsCache, int CurrentFrame){
-        try(var MemStack = MemoryStack.stackPush()){
-            VkCommandBuffer CommandHandle = commandBuffer.GetVulkanCommandBuffer();
-
-            List<Attachment> ColourAttachments = MRTAttachments.GetColourAttachments();
-            int AttachmentCount = ColourAttachments.size();
-            for(int i = 0; i < AttachmentCount; i++) {
-                Attachment colourAttachment = ColourAttachments.get(i);
-                VulkanUtils.ImageBarrier(MemStack, CommandHandle, colourAttachment.GetVkImage().getVulkanImage(),
-                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                        VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT,
-                        VK_ACCESS_NONE, VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT,
-                        VK_IMAGE_ASPECT_COLOR_BIT);
-            }
-            VulkanUtils.ImageBarrier(MemStack, CommandHandle, MRTAttachments.GetDepthAttachment().GetVkImage().getVulkanImage(),
-                    VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,
-                    VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
-                    VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT,
-                    VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
-                    VK_IMAGE_ASPECT_DEPTH_BIT);
-
-            long InitialTime = System.nanoTime();
-            vkCmdBeginRendering(CommandHandle, RenderInfo);
-
-            vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, DualPassRendering ? VkPipelineOpaque.GetVulkanPipeline() : VkPipeline.GetVulkanPipeline());
-
-            int width = MRTAttachments.GetWidth();
-            int height = MRTAttachments.GetHeight();
-            var Viewport = VkViewport.calloc(1,MemStack)
-                    .x(0)
-                    .y(height)
-                    .height(-height)
-                    .width(width)
-                    .minDepth(0.0F)
-                    .maxDepth(1.0F);
-            vkCmdSetViewport(CommandHandle, 0, Viewport);
-            var Scissor = VkRect2D.calloc(1,MemStack)
-                    .extent(it -> it.width(width).height(height))
-                    .offset(it->it.x(0).y(0));
-            vkCmdSetScissor(CommandHandle, 0, Scissor);
-
-            VulkanUtils.CopyMatrixToBuffer(vulkanContext, BufferViewMatrices[CurrentFrame],engineInstance.scene().GetCamera().GetViewMatrix(), 0); // here
-            DescriptorAllocator descriptorAllocator = vulkanContext.GetDescriptorAllocator();
-            LongBuffer DescriptorSets = MemStack.mallocLong(4)
-                    .put(0,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_PRJ).GetVkDescriptorSet())
-                    .put(1,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_VIEW, CurrentFrame).GetVkDescriptorSet())
-                    .put(2,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_MAT).GetVkDescriptorSet())
-                    .put(3,descriptorAllocator.GetDescriptorSet(DESCRIPTOR_ID_TEXT).GetVkDescriptorSet());
-            vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, DualPassRendering ? VkPipelineOpaque.GetVulkanPipelineLayout() : VkPipeline.GetVulkanPipelineLayout(),0,DescriptorSets,null);
-
-            RenderActors(engineInstance, CommandHandle, modelsCache, materialsCache, false);
-            if(DualPassRendering) {
-                vkCmdBindPipeline(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, VkPipelineTranslucent.GetVulkanPipeline());
-                vkCmdSetViewport(CommandHandle, 0, Viewport);
-                vkCmdSetScissor(CommandHandle, 0, Scissor);
-                vkCmdBindDescriptorSets(CommandHandle, VK_PIPELINE_BIND_POINT_GRAPHICS, VkPipelineTranslucent.GetVulkanPipelineLayout(), 0, DescriptorSets, null);
-            }
-            RenderActors(engineInstance, CommandHandle, modelsCache, materialsCache, true);
-
-            vkCmdEndRendering(CommandHandle);
-            GPUTIME += System.nanoTime() - InitialTime;
-            CYCLES++;
-        }
-    }
-
-    public MultiRenderTargetAttachments GetMRTAttachments(){
-        return MRTAttachments;
-    }
 
     public void Render(EngineInstance engineInstance,VulkanContext vulkanContext, CommandBuffer commandBuffer, ModelsCache modelsCache,MaterialsCache materialsCache, int CurrentFrame){
 
-        if(Deferred) DeferredRender(engineInstance,vulkanContext,commandBuffer,modelsCache,materialsCache,CurrentFrame);
+        ForwardRender(engineInstance,vulkanContext,commandBuffer,modelsCache,materialsCache,CurrentFrame);
-        else ForwardRender(engineInstance,vulkanContext,commandBuffer,modelsCache,materialsCache,CurrentFrame);
     }
 
     private void RenderActors(EngineInstance instance, VkCommandBuffer CommandHandle, ModelsCache modelsCache, MaterialsCache materialsCache, boolean Transparent){
@@ -462,9 +338,7 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
     public void Resize(EngineInstance instance, VulkanContext VkCtx){
         RenderInfo.free();
         AttachmentInfoDepth.free();
-        MRTAttachments.CleanUp(VkCtx);
+        AttachmentInfoColour.free();
-        if(Deferred)Arrays.asList(AttachmentInfoColour).forEach(VkRenderingAttachmentInfo.Buffer::free);
-        else AttachmentInfoColour.free();
         AttachmentColour.CleanUp(VkCtx);
         AttachmentDepth.CleanUp(VkCtx);
         CreateRenderAttachments(VkCtx);
@@ -517,13 +391,14 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
     public void cleanup(VulkanContext VkCtx){
 
         VkPipeline.CleanUp(VkCtx);
+        VkPipelineTranslucent.CleanUp(VkCtx);
+        VkPipelineOpaque.CleanUp(VkCtx);
         Arrays.asList(BufferViewMatrices).forEach(buffer -> buffer.cleanup(VkCtx));
         RenderInfo.free();
         AttachmentInfoColour.free();
         AttachmentColour.CleanUp(VkCtx);
         AttachmentDepth.CleanUp(VkCtx);
         AttachmentInfoDepth.free();
-        MRTAttachments.CleanUp(VkCtx);
         MemoryUtil.memFree(PushConstBuffer);
         ClearValueDepth.free();
         ClearValueColour.free();
@@ -534,6 +409,11 @@ public class SceneRender implements SceneRenderer {//dynamic rendering
         textureSampler.CleanUp(VkCtx);
     }
 
+    @Override
+    public MultiRenderTargetAttachments GetMRTAttachments() {
+        return null;
+    }
+
     @Override
     public Attachment GetAttachmentColour() {
         return AttachmentColour;

src/main/java/net/halbear/Terrain4J/EngineCore/Vulkan/Structure/DisplayToScreen/SceneRenderer.java

@@ -2,7 +2,7 @@ package net.halbear.Terrain4J.EngineCore.Vulkan.Structure.DisplayToScreen;
 
 import net.halbear.Terrain4J.EngineCore.Logic.EngineInstance;
 import net.halbear.Terrain4J.EngineCore.Logic.Rendering.VulkanContext;
-import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Deferred.MultiRenderTargetAttachments;
+import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.DeferredRendering.MultiRenderTargetAttachments;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.Attachment;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Images.TextureCache;
 import net.halbear.Terrain4J.EngineCore.Vulkan.Rendering.Pipeline.Pipeline;
@@ -21,7 +21,7 @@ public interface SceneRenderer {
     public void Resize(EngineInstance instance, VulkanContext VkCtx);
     public void LoadMaterials(VulkanContext VkCtx, MaterialsCache materialsCache, TextureCache textureCache);
     public void cleanup(VulkanContext VkCtx);
-    public Attachment GetAttachmentColour();
     public MultiRenderTargetAttachments GetMRTAttachments();
-    public boolean GetCurrentDeferred();
+    public Attachment GetAttachmentColour();
+    public void RebuildPipelines(VulkanContext VkCtx);
 }

terrain4j.properties

@@ -26,7 +26,7 @@ compatibility_mode=false
 #Renderer Settings
 #0 = Forward rendering
 #1 = Deferred rendering
-Renderer=0
+Renderer=1
 AlphaToCoverage=false
 DualPassRendering=true
 #AA settings
@@ -35,7 +35,7 @@ DualPassRendering=true
 #2=MSAAx2
 #3=MSAAx4
 #4=MSAAx8
-anti_alias_mode=2
+anti_alias_mode=0
 Debug_Shaders = false
 ShaderRecompiling = true
 #Vulkan Debugging toggle