From 1bfa93eea3bb291594731a85f14189d2aa645a0d Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 23 Feb 2026 12:32:14 -0600 Subject: [PATCH 01/72] proof-of-concept test renderer --- .../common/AbstractModInitializer.java | 2 + .../common/renderTest/McTestRenderer.java | 292 ++++++++++++++++++ .../common/wrappers/DependencySetup.java | 7 + coreSubProjects | 2 +- fabric/build.gradle | 2 +- .../assets/distanthorizons/shaders/frag.frag | 9 + .../assets/distanthorizons/shaders/vert.vert | 0 fabric/src/main/resources/pack.mcmeta | 12 + 8 files changed, 324 insertions(+), 2 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java create mode 100644 fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag create mode 100644 fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert create mode 100644 fabric/src/main/resources/pack.mcmeta diff --git a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java index e41c5174f..821274c31 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java @@ -18,6 +18,7 @@ import com.seibel.distanthorizons.core.enums.MinecraftTextFormat; import com.seibel.distanthorizons.core.jar.ModJarInfo; import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.glObject.GLProxy; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModChecker; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; @@ -66,6 +67,7 @@ public abstract class AbstractModInitializer public void onInitializeClient() { + GLProxy.queueRunningOnRenderThread(() -> { DependencySetup.createRenderBindings(); }); DependencySetup.createClientBindings(); this.createInitialClientBindings(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java new file mode 100644 index 000000000..b531083d9 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -0,0 +1,292 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.opengl.*; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.CompiledRenderPipeline; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.LogicOp; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.ShaderSource; +import com.mojang.blaze3d.shaders.ShaderType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.DefaultVertexFormat; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.core.render.glObject.shader.Shader; +import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.core.util.ColorUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.ShaderDefines; +import net.minecraft.client.renderer.ShaderManager; +import net.minecraft.resources.Identifier; +import net.minecraft.server.packs.resources.Resource; +import net.minecraft.server.packs.resources.ResourceManager; +import net.minecraft.util.StringUtil; +import org.jspecify.annotations.Nullable; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL43; + +import java.io.*; +import java.lang.reflect.Field; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.List; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +import static com.ibm.icu.impl.ValidIdentifiers.Datatype.x; + +/** + * Renders a UV colored quad + * to the center of the screen to confirm DH's + * apply shader is running correctly + */ +public class McTestRenderer implements IMcTestRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McTestRenderer INSTANCE = new McTestRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private VertexFormatElement posForm; + private VertexFormatElement colForm; + + + //=============// + // constructor // + //=============// + //region + + private McTestRenderer() + { + this.posForm = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); + this.colForm = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", this.posForm) + .add("vColor", this.colForm) + .build(); + + int breakpointOne = 0; + // needs to manually be set if the VertexFormatElement isn't registered + this.vertexFormat.getOffsetsByElement()[this.posForm.id()] = 0; + this.vertexFormat.getOffsetsByElement()[this.colForm.id()] = Float.BYTES * 2; + + int breakpointTwo = 0; + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + //builder.withBlend(BlendFunction.OVERLAY); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "frag")); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.tryInit(); + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + // upload vertex data + GpuBuffer vboGpuBuffer; + { + // vertices for the OpenGL/Vulkan Triangle + float[] vertices = new float[] + { + // PosX,Y, ColorR,G,B,A + -0.5f, -0.5f, 255.0f, 000.0f, 000.0f, 255.0f, + 0.5f, -0.5f, 000.0f, 255.0f, 000.0f, 255.0f, + 0.0f, 0.5f, 000.0f, 000.0f, 255.0f, 255.0f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McTestRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + // create a render pass + { + Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // set uniform + if (false) + { + Supplier labelSupplier = () -> ""; + int usage = 0; + int size = 0; + GpuBuffer gpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + renderPass.setUniform("name", gpuBuffer); + } + + // bind depth texture + if (false) + { + GpuTexture bindDepthTexture = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); + + GpuTextureView textureView = gpuDevice.createTextureView(bindDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 0, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("depth", textureView, gpuSampler); + } + + // index buffer + if (false) + { + GpuBuffer buffer = null; + renderPass.setIndexBuffer(buffer, VertexFormat.IndexType.INT); + } + + // bind VBO + { + renderPass.setVertexBuffer(0, vboGpuBuffer); // vertex buffer can only be "0" lol + } + + // set pipeline + { + renderPass.setPipeline(this.pipeline); + } + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 3; + renderPass.draw(indexStart, indexCount); + } + } + + // can only be closed after rendering is done + vboGpuBuffer.close(); + } + + // clear depth texture + { + //GpuTexture depthTex = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); + //double newDepth = 0; + //commandEncoder.clearDepthTexture(depthTex, newDepth); + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index b8fb6a99f..0eb59f2b8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,6 +19,7 @@ package com.seibel.distanthorizons.common.wrappers; +import com.seibel.distanthorizons.common.renderTest.McTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; @@ -36,6 +37,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; /** * Binds all necessary dependencies, so we @@ -70,4 +72,9 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IConfigGui.class, ClassicConfigGUI.CONFIG_CORE_INTERFACE); } + public static void createRenderBindings() + { + SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); + } + } diff --git a/coreSubProjects b/coreSubProjects index ed0e94ccb..1b2992f1d 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit ed0e94ccb7c9de90b7b130b349b56f367a62a92c +Subproject commit 1b2992f1dcb6d0588f6c3d189b36e5aad37022cc diff --git a/fabric/build.gradle b/fabric/build.gradle index 77fabeb80..81076a957 100644 --- a/fabric/build.gradle +++ b/fabric/build.gradle @@ -23,7 +23,7 @@ loom { "-XX:+UseZGC", "-XX:+ZGenerational" ) - programArgs("--username", "Dev") + programArgs("--username", "Dev", "--renderDebugLabels") } server { server() diff --git a/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag b/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag new file mode 100644 index 000000000..2a8a4d685 --- /dev/null +++ b/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag @@ -0,0 +1,9 @@ +#version 150 core + +in vec4 fColor; +out vec4 fragColor; + +void main() +{ + fragColor = fColor; +} \ No newline at end of file diff --git a/fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert b/fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert new file mode 100644 index 000000000..e69de29bb diff --git a/fabric/src/main/resources/pack.mcmeta b/fabric/src/main/resources/pack.mcmeta new file mode 100644 index 000000000..f48d006ff --- /dev/null +++ b/fabric/src/main/resources/pack.mcmeta @@ -0,0 +1,12 @@ +{ + "pack": { + "pack_format": 64, + "supported_formats": { + "min_inclusive": 64, + "max_inclusive": 90000 + }, + "description": "Distant Horizons", + "min_format": 64, + "max_format": 90000 + } +} From 933d5c957c6cf41d6384690a91f501d67265867a Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 23 Feb 2026 17:09:02 -0600 Subject: [PATCH 02/72] Fix buffer deleted too quickly and color ranges --- .../common/renderTest/McTestRenderer.java | 73 ++++++++++--------- 1 file changed, 38 insertions(+), 35 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java index b531083d9..c42aa3cb9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -94,6 +94,8 @@ public class McTestRenderer implements IMcTestRenderer private VertexFormatElement posForm; private VertexFormatElement colForm; + private GpuBuffer vboGpuBuffer; + //=============// // constructor // @@ -116,6 +118,9 @@ public class McTestRenderer implements IMcTestRenderer + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + this.vertexFormat = VertexFormat.builder() .add("vPosition", this.posForm) @@ -147,6 +152,39 @@ public class McTestRenderer implements IMcTestRenderer } this.pipeline = pipelineBuilder.build(); + + // upload vertex data + { + // vertices for the OpenGL/Vulkan Triangle + float[] vertices = new float[] + { + // PosX,Y, ColorR,G,B,A + -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, + 0.0f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McTestRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + } //endregion @@ -168,38 +206,6 @@ public class McTestRenderer implements IMcTestRenderer CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - // upload vertex data - GpuBuffer vboGpuBuffer; - { - // vertices for the OpenGL/Vulkan Triangle - float[] vertices = new float[] - { - // PosX,Y, ColorR,G,B,A - -0.5f, -0.5f, 255.0f, 000.0f, 000.0f, 255.0f, - 0.5f, -0.5f, 000.0f, 255.0f, 000.0f, 255.0f, - 0.0f, 0.5f, 000.0f, 000.0f, 255.0f, 255.0f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McTestRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } // create a render pass { @@ -272,9 +278,6 @@ public class McTestRenderer implements IMcTestRenderer renderPass.draw(indexStart, indexCount); } } - - // can only be closed after rendering is done - vboGpuBuffer.close(); } // clear depth texture From 5b825f9dbba4cf5f6b3c9103013ed7398e5f2837 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 24 Feb 2026 07:02:16 -0600 Subject: [PATCH 03/72] move test shader folder --- .../distanthorizons/common/renderTest/McTestRenderer.java | 4 ++-- coreSubProjects | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java index c42aa3cb9..3803caf3e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -145,8 +145,8 @@ public class McTestRenderer implements IMcTestRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/frag")); pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); } diff --git a/coreSubProjects b/coreSubProjects index 1b2992f1d..87cead607 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 1b2992f1dcb6d0588f6c3d189b36e5aad37022cc +Subproject commit 87cead607fddddcd5c93770fc81fc4aa6bd3eebc From 183882f9cee124ae3891702c60fbc02bc3192c76 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 24 Feb 2026 09:57:13 -0600 Subject: [PATCH 04/72] start of vanilla fade logic --- .../common/renderTest/DhVertexFormat.java | 11 + .../common/renderTest/McFadeRenderer.java | 233 ++++++++++++++++++ .../common/renderTest/McTestRenderer.java | 22 +- .../common/wrappers/DependencySetup.java | 3 + coreSubProjects | 2 +- 5 files changed, 257 insertions(+), 14 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java new file mode 100644 index 000000000..fd4192f0a --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java @@ -0,0 +1,11 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.vertex.VertexFormatElement; + +public class DhVertexFormat +{ + + public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); + public static final VertexFormatElement RGBA_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java new file mode 100644 index 000000000..422ce841a --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -0,0 +1,233 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * Renders a UV colored quad + * to the center of the screen to confirm DH's + * apply shader is running correctly + */ +public class McFadeRenderer implements IMcFadeRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McFadeRenderer INSTANCE = new McFadeRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer vboGpuBuffer; + + + //=============// + // constructor // + //=============// + //region + + private McFadeRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + //builder.withBlend(BlendFunction.OVERLAY); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/frag")); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.tryInit(); + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McFadeRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null;//gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind MC depth texture + { + IMinecraftRenderWrapper mcRender = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + int id = mcRender.getDepthTextureId(); + + GpuTexture bindDepthTexture = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); + + GpuTextureView textureView = gpuDevice.createTextureView(bindDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + // bind VBO + { + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + } + + // set pipeline + { + renderPass.setPipeline(this.pipeline); + } + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java index 3803caf3e..b693e424f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -91,9 +91,6 @@ public class McTestRenderer implements IMcTestRenderer private RenderPipeline pipeline; private boolean init = false; - private VertexFormatElement posForm; - private VertexFormatElement colForm; - private GpuBuffer vboGpuBuffer; @@ -104,8 +101,7 @@ public class McTestRenderer implements IMcTestRenderer private McTestRenderer() { - this.posForm = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); - this.colForm = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + } private void tryInit() @@ -123,16 +119,16 @@ public class McTestRenderer implements IMcTestRenderer this.vertexFormat = VertexFormat.builder() - .add("vPosition", this.posForm) - .add("vColor", this.colForm) + .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vColor", DhVertexFormat.RGBA_COLOR) .build(); - int breakpointOne = 0; + //int breakpointOne = 0; // needs to manually be set if the VertexFormatElement isn't registered - this.vertexFormat.getOffsetsByElement()[this.posForm.id()] = 0; - this.vertexFormat.getOffsetsByElement()[this.colForm.id()] = Float.BYTES * 2; - - int breakpointTwo = 0; + //this.vertexFormat.getOffsetsByElement()[this.posForm.id()] = 0; + //this.vertexFormat.getOffsetsByElement()[this.colForm.id()] = Float.BYTES * 2; + // + //int breakpointTwo = 0; RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); @@ -148,7 +144,7 @@ public class McTestRenderer implements IMcTestRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/frag")); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 0eb59f2b8..9f4a935d3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,6 +19,7 @@ package com.seibel.distanthorizons.common.wrappers; +import com.seibel.distanthorizons.common.renderTest.McFadeRenderer; import com.seibel.distanthorizons.common.renderTest.McTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; @@ -37,6 +38,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; /** @@ -75,6 +77,7 @@ public class DependencySetup public static void createRenderBindings() { SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcFadeRenderer.class, McFadeRenderer.INSTANCE); } } diff --git a/coreSubProjects b/coreSubProjects index 87cead607..d1ba402f4 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 87cead607fddddcd5c93770fc81fc4aa6bd3eebc +Subproject commit d1ba402f4d1db1f8cd98ef880984de089429153b From e59c22fb6976db06f2408cb45e93291daa973d58 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 24 Feb 2026 22:03:54 -0600 Subject: [PATCH 05/72] Fix fade shader not binding MC depth texture --- .../distanthorizons/common/renderTest/McFadeRenderer.java | 3 +++ coreSubProjects | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java index 422ce841a..41382dff7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -68,6 +68,7 @@ public class McFadeRenderer implements IMcFadeRenderer private GpuBuffer vboGpuBuffer; + //=============// // constructor // //=============// @@ -110,6 +111,8 @@ public class McFadeRenderer implements IMcFadeRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/frag")); + pipelineBuilder.withSampler("uDhDepthTexture"); + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/coreSubProjects b/coreSubProjects index d1ba402f4..9f483ee07 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit d1ba402f4d1db1f8cd98ef880984de089429153b +Subproject commit 9f483ee07a78dcfb00744f623761efed65c24b9c From f1e93ad54789d919e5c59759a2f97e6a536525c2 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 24 Feb 2026 22:23:39 -0600 Subject: [PATCH 06/72] add mixinSharedConstants --- .../common/renderTest/McFadeRenderer.java | 3 -- .../mixins/client/MixinSharedConstants.java | 35 +++++++++++++++++++ .../DistantHorizons.fabric.mixins.json | 3 +- 3 files changed, 37 insertions(+), 4 deletions(-) create mode 100644 fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinSharedConstants.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java index 41382dff7..86ec82359 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -194,9 +194,6 @@ public class McFadeRenderer implements IMcFadeRenderer { // bind MC depth texture { - IMinecraftRenderWrapper mcRender = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - int id = mcRender.getDepthTextureId(); - GpuTexture bindDepthTexture = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); GpuTextureView textureView = gpuDevice.createTextureView(bindDepthTexture); diff --git a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinSharedConstants.java b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinSharedConstants.java new file mode 100644 index 000000000..c747d8335 --- /dev/null +++ b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinSharedConstants.java @@ -0,0 +1,35 @@ +package com.seibel.distanthorizons.fabric.mixins.client; + +import com.seibel.distanthorizons.common.commonMixins.DhUpdateScreenBase; +import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; +import com.seibel.distanthorizons.core.api.internal.ClientApi; +import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import net.minecraft.SharedConstants; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.ClientLevel; +import org.spongepowered.asm.mixin.*; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.Redirect; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +/** + * At the moment this is only used for the auto updater + * + * @author coolGi + */ +@Mixin(SharedConstants.class) +public abstract class MixinSharedConstants +{ + @Mutable + @Shadow @Final public static boolean IS_RUNNING_IN_IDE; + + @Inject(method = "", at = @At("TAIL")) + private static void setIsRunningInIde(CallbackInfo ci) + { + IS_RUNNING_IN_IDE = true; + } + +} diff --git a/fabric/src/main/resources/DistantHorizons.fabric.mixins.json b/fabric/src/main/resources/DistantHorizons.fabric.mixins.json index 9faea69bf..92f07d61c 100644 --- a/fabric/src/main/resources/DistantHorizons.fabric.mixins.json +++ b/fabric/src/main/resources/DistantHorizons.fabric.mixins.json @@ -20,7 +20,8 @@ "client.MixinChunkSectionsToRender", "client.MixinLightTexture", "client.MixinMinecraft", - "client.MixinOptionsScreen" + "client.MixinOptionsScreen", + "client.MixinSharedConstants" ], "server": [], "injectors": { From b5eff6aa80889f0c4743f176d11f9a7e556c7261 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 24 Feb 2026 22:23:47 -0600 Subject: [PATCH 07/72] remove unused shader files --- .../resources/assets/distanthorizons/shaders/frag.frag | 9 --------- .../resources/assets/distanthorizons/shaders/vert.vert | 0 2 files changed, 9 deletions(-) delete mode 100644 fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag delete mode 100644 fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert diff --git a/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag b/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag deleted file mode 100644 index 2a8a4d685..000000000 --- a/fabric/src/main/resources/assets/distanthorizons/shaders/frag.frag +++ /dev/null @@ -1,9 +0,0 @@ -#version 150 core - -in vec4 fColor; -out vec4 fragColor; - -void main() -{ - fragColor = fColor; -} \ No newline at end of file diff --git a/fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert b/fabric/src/main/resources/assets/distanthorizons/shaders/vert.vert deleted file mode 100644 index e69de29bb..000000000 From 36ad3f4e43c57ec18b011c9d7d7318642acc234e Mon Sep 17 00:00:00 2001 From: James Seibel Date: Thu, 26 Feb 2026 16:56:26 -0600 Subject: [PATCH 08/72] rough initial LOD rendering --- .../common/renderTest/DhVertexFormat.java | 11 +- .../common/renderTest/McFadeRenderer.java | 4 +- .../common/renderTest/McLodRenderer.java | 534 ++++++++++++++++++ .../common/renderTest/McTestRenderer.java | 30 +- .../renderTest/VertexBufferWrapper.java | 63 +++ .../common/wrappers/DependencySetup.java | 3 + .../common/wrappers/WrapperFactory.java | 8 + coreSubProjects | 2 +- 8 files changed, 620 insertions(+), 35 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java index fd4192f0a..362a60d6a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java @@ -4,8 +4,15 @@ import com.mojang.blaze3d.vertex.VertexFormatElement; public class DhVertexFormat { - public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); - public static final VertexFormatElement RGBA_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + public static final VertexFormatElement RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + + public static final VertexFormatElement SHORT_POS = VertexFormatElement.register(/*id*/9, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + public static final VertexFormatElement BYTE_PAD = VertexFormatElement.register(/*id*/10, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + public static final VertexFormatElement LIGHT = VertexFormatElement.register(/*id*/11, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + public static final VertexFormatElement RGBA_UBYTE_COLOR = VertexFormatElement.register(/*id*/12, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.COLOR, /*count*/ 4); + public static final VertexFormatElement IRIS_MATERIAL = VertexFormatElement.register(/*id*/13, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + public static final VertexFormatElement IRIS_NORMAL = VertexFormatElement.register(/*id*/14, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java index 86ec82359..051ec9511 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -48,9 +48,7 @@ import java.util.OptionalInt; import java.util.function.Supplier; /** - * Renders a UV colored quad - * to the center of the screen to confirm DH's - * apply shader is running correctly + * Renders a TODO */ public class McFadeRenderer implements IMcFadeRenderer { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java new file mode 100644 index 000000000..f3c9274d4 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -0,0 +1,534 @@ +package com.seibel.distanthorizons.common.renderTest; + + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.glObject.GLEnums; +import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; +import org.lwjgl.opengl.GL32; +import org.lwjgl.system.MemoryUtil; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.FloatBuffer; +import java.nio.IntBuffer; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Consumer; +import java.util.function.Supplier; + +/** + * Renders a TODO + */ +public class McLodRenderer implements IMcLodRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McLodRenderer INSTANCE = new McLodRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline opaquePipeline; + private RenderPipeline transparentPipeline; + private boolean init = false; + + + + //=============// + // constructor // + //=============// + //region + + private McLodRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; // todo only set when succeeded (in case of exception) + + + + //GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); + //GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SHORT_POS) //.add(ELEMENT_POSITION) + .add("paddingOne", DhVertexFormat.BYTE_PAD) //.add(ELEMENT_BYTE_PADDING) + .add("light", DhVertexFormat.LIGHT)//.add(ELEMENT_LIGHT) + .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR)//.add(ELEMENT_COLOR) + .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL)//.add(ELEMENT_IRIS_MATERIAL_INDEX) + .add("irisNormal", DhVertexFormat.IRIS_NORMAL)//.add(ELEMENT_IRIS_NORMAL_INDEX) + .add("paddingTwo", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) + .add("paddingThree", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) // padding is to make sure the format is a multiple of 4 + .build(); + + + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(true); + pipelineBuilder.withDepthWrite(true); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:lod_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/frag")); + + //pipelineBuilder.withSampler("uLightMap"); // TODO + + pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); + pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + } + + // opaque + { + pipelineBuilder.withoutBlend(); + this.opaquePipeline = pipelineBuilder.build(); + } + + // transparent + { + pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); + this.transparentPipeline = pipelineBuilder.build(); + } + + + + } + + /** + * There's an Std180Builder and Std180SizeCalculator, if you missed them. Ensure the ubo in the shader is marked std180. + * These help keep alignment rules in check + */ + private static ByteBuffer setUniform(ByteBuffer oldBuffer, Mat4f matrix) + { + return setUniform(oldBuffer, "Mat4f", (buffer) -> + { + FloatBuffer floatBuffer = buffer.asFloatBuffer(); + matrix.store(floatBuffer); + }); + } + private static ByteBuffer setUniform(ByteBuffer oldBuffer, DhApiVec3f vector) + { + return setUniform(oldBuffer, "Vec3f", (buffer) -> + { + FloatBuffer floatBuffer = buffer.asFloatBuffer(); + floatBuffer + .put(vector.x) + .put(vector.y) + .put(vector.z) + .put(0f); + }); + } + private static ByteBuffer setUniform(ByteBuffer oldBuffer, boolean value) + { + return setUniform(oldBuffer, "boolean", (buffer) -> + { + IntBuffer intBuffer = buffer.asIntBuffer(); + intBuffer.put(value ? 1 : 0); + }); + } + private static ByteBuffer setUniform(ByteBuffer oldBuffer, float value) + { + return setUniform(oldBuffer, "float", (buffer) -> + { + FloatBuffer floatBuffer = buffer.asFloatBuffer(); + floatBuffer.put(value); + }); + } + private static ByteBuffer setUniform(ByteBuffer oldBuffer, int value) + { + return setUniform(oldBuffer, "int", (buffer) -> + { + IntBuffer intBuffer = buffer.asIntBuffer(); + intBuffer.put(value); + }); + } + private static ByteBuffer setUniform(ByteBuffer oldBuffer, String uploadType, Consumer modifyFunc) + { + int lengthInBytes; + switch (uploadType) + { + case "Mat4f": + lengthInBytes = 4 * 4 * Float.BYTES; + break; + case "float": + lengthInBytes = Float.BYTES; + break; + case "Vec3f": + lengthInBytes = 4 * Float.BYTES; + break; + case "int": + case "boolean": + lengthInBytes = Integer.BYTES; + break; + + default: + throw new UnsupportedOperationException("No known type ["+uploadType+"]"); + } + + + // buffer to upload data + ByteBuffer newBuffer = ByteBuffer.allocateDirect(oldBuffer.capacity() + lengthInBytes); + newBuffer.order(ByteOrder.nativeOrder()); + newBuffer.put(oldBuffer); + modifyFunc.accept(newBuffer); + newBuffer.rewind(); + + return newBuffer; + } + + private static GpuBuffer finalizeUniformBuffer(String uniformName, ByteBuffer buffer, GpuBuffer vboGpuBuffer) + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + // create VBO if needed + if (vboGpuBuffer == null + || vboGpuBuffer.size() < buffer.capacity()) + { + // GpuBuffer.USAGE_UNIFORM = 128 + int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, buffer.capacity()); + } + + int offset = 0; + GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, offset, buffer.capacity()); + commandEncoder.writeToBuffer(bufferSlice, buffer); + + return vboGpuBuffer; + } + + private GpuBuffer indexBuffer; + + private GpuBuffer fragUniformBuffer; + private GpuBuffer vertUniformBuffer; + + private GpuTexture depthTexture; + + //endregion + + @Override + public int getVertexSize() + { + VertexFormat format = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SHORT_POS) //.add(ELEMENT_POSITION) + .add("paddingOne", DhVertexFormat.BYTE_PAD) //.add(ELEMENT_BYTE_PADDING) + .add("light", DhVertexFormat.LIGHT)//.add(ELEMENT_LIGHT) + .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR)//.add(ELEMENT_COLOR) + .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL)//.add(ELEMENT_IRIS_MATERIAL_INDEX) + .add("irisNormal", DhVertexFormat.IRIS_NORMAL)//.add(ELEMENT_IRIS_NORMAL_INDEX) + .add("paddingTwo", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) + .add("paddingThree", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) // padding is to make sure the format is a multiple of 4 + .build(); + + return format.getVertexSize(); + } + + + + //========// + // render // + //========// + //region + + //@Override + //public void fillUniformData() + //{ + // + //} + //@Override + //public void setModelOffsetPos() + //{ + // + //} + + @Override + public void render( + DhApiRenderParam renderEventParam, + boolean opaquePass, + DhApiVec3f modelOffset, + IVertexBufferWrapper[] bufferList, + IProfilerWrapper profiler) + { + this.tryInit(); + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + + profiler.push("set vert uniforms"); + { + ByteBuffer buffer = ByteBuffer.allocateDirect(0); + buffer.order(ByteOrder.nativeOrder()); + + buffer = setUniform(buffer, false); // "uIsWhiteWorld" + + buffer = setUniform(buffer, false); // spacer 1 + buffer = setUniform(buffer, false); // spacer 2 + buffer = setUniform(buffer, false); // spacer 3 + + Mat4f combinedMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); + combinedMatrix.multiply(renderEventParam.dhModelViewMatrix); + buffer = setUniform(buffer, combinedMatrix); // uCombinedMatrix + + buffer = setUniform(buffer, modelOffset); // uModelOffset + buffer = setUniform(buffer, renderEventParam.worldYOffset); // uWorldYOffset + buffer = setUniform(buffer, 0.01f); // uMircoOffset // 0.01 block offset + + float curveRatio = Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.get(); + if (curveRatio < -1.0f || curveRatio > 1.0f) + { + curveRatio = /*6371KM*/ 6371000.0f / curveRatio; + } + else + { + // disable curvature if the config value is between -1 and 1 + curveRatio = 0.0f; + } + buffer = setUniform(buffer, curveRatio); // uEarthRadius + + this.vertUniformBuffer = finalizeUniformBuffer("vertUniformBlock", buffer, this.vertUniformBuffer); + } + + + profiler.popPush("set frag uniforms"); + { + ByteBuffer buffer = ByteBuffer.allocateDirect(0); + buffer.order(ByteOrder.nativeOrder()); + + + // Clip Uniform + float dhNearClipDistance = RenderUtil.getNearClipPlaneInBlocks(); + if (!Config.Client.Advanced.Debugging.lodOnlyMode.get()) + { + // this added value prevents the near clip plane and discard circle from touching, which looks bad + dhNearClipDistance += 16f; + } + buffer = setUniform(buffer, dhNearClipDistance); // "uClipDistance" + + // Noise Uniforms + buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.enableNoiseTexture.get()); // "uNoiseEnabled" + buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseSteps.get()); // "uNoiseSteps" + buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseIntensity.get()); // "uNoiseIntensity" + buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseDropoff.get()); // "uNoiseDropoff" + buffer = setUniform(buffer, Config.Client.Advanced.Graphics.Quality.ditherDhFade.get()); // "uDitherDhRendering" + + this.fragUniformBuffer = finalizeUniformBuffer("fragUniformBlock", buffer, this.fragUniformBuffer); + } + + profiler.popPush("create index buffer"); + { + if (this.indexBuffer == null) + { + ByteBuffer buffer = MemoryUtil.memAlloc(LodBufferContainer.MAX_QUADS_PER_BUFFER * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6); + QuadElementBuffer.buildBuffer(LodBufferContainer.MAX_QUADS_PER_BUFFER, buffer, GL32.GL_UNSIGNED_INT); + + + // create VBO if needed + if (indexBuffer == null + || indexBuffer.size() < buffer.capacity()) + { + // GpuBuffer.USAGE_UNIFORM = 128 + // GpuBuffer.USAGE_INDEX = 64 + int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + this.indexBuffer = gpuDevice.createBuffer(() -> "DH Index Buffer", usage, buffer.capacity()); + } + + int offset = 0; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexBuffer, offset, buffer.capacity()); + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + } + + // depth text + if (this.depthTexture == null + || this.depthTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.depthTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + { + if (this.depthTexture != null) + { + this.depthTexture.close(); + } + + int usage = 8 | 32 | 128; + this.depthTexture = gpuDevice.createTexture("DhDepthTexture", + usage, + TextureFormat.DEPTH32, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); + } + + + profiler.popPush("create render pass"); + + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McLodRenderer"; + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try ( + GpuTextureView colorTextureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + GpuTextureView depthTextureView = gpuDevice.createTextureView(this.depthTexture); + RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTextureView, + optionalClearColorAsInt, + depthTextureView, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + //renderPass.bindTexture("uLightMap", ); + + + + renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + + //pipelineBuilder.withSampler("uLightMap"); + + + //boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); + //if (renderWireframe) + //{ + // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + // GLMC.disableFaceCulling(); + //} + //else + //{ + // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + // GLMC.enableFaceCulling(); + //} + // + //if (!opaquePass) + //{ + // GLMC.enableBlend(); + // GLMC.enableDepthTest(); + // GL32.glBlendEquation(GL32.GL_FUNC_ADD); + // GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + //} + //else + //{ + // GLMC.disableBlend(); + //} + + + profiler.popPush("set pipeline"); + + renderPass.setPipeline(opaquePass ? this.opaquePipeline : this.transparentPipeline); + renderPass.setIndexBuffer(this.indexBuffer, VertexFormat.IndexType.INT); + + // render pass setup + for (int i = 0; i < bufferList.length; i++) + { + VertexBufferWrapper bufferWrapper = (VertexBufferWrapper)bufferList[i]; + if (!bufferWrapper.uploaded + || bufferWrapper.vertexCount == 0) + { + continue; + } + + profiler.popPush("set VBO"); + + renderPass.setVertexBuffer(0, bufferWrapper.vboGpuBuffer); // vertex buffer can only be "0" lol + + profiler.popPush("render"); + + try + { + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/ + (int)(bufferWrapper.vertexCount * 1.5), // convert vertex count to index count // TODO fix me! + //LodBufferContainer.MAX_QUADS_PER_BUFFER, + /*instanceCount*/1); + + } + catch (IllegalStateException e) + { + if (!e.getMessage().contains("Vertex buffer at slot 0 has been closed")) + { + throw new RuntimeException(e); + } + } + + } + } + + + + profiler.pop(); + } + + public void clearDepth() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + if (this.depthTexture != null) + { + commandEncoder.clearDepthTexture(this.depthTexture, 1.0f); + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java index b693e424f..ab6d739f4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -21,58 +21,30 @@ package com.seibel.distanthorizons.common.renderTest; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.opengl.*; -import com.mojang.blaze3d.pipeline.BlendFunction; -import com.mojang.blaze3d.pipeline.CompiledRenderPipeline; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; -import com.mojang.blaze3d.platform.LogicOp; import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.shaders.ShaderSource; -import com.mojang.blaze3d.shaders.ShaderType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; -import com.mojang.blaze3d.vertex.DefaultVertexFormat; import com.mojang.blaze3d.vertex.VertexFormat; -import com.mojang.blaze3d.vertex.VertexFormatElement; -import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.glObject.buffer.GLVertexBuffer; -import com.seibel.distanthorizons.core.render.glObject.shader.Shader; -import com.seibel.distanthorizons.core.render.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.core.render.glObject.vertexAttribute.VertexPointer; -import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.ShaderDefines; -import net.minecraft.client.renderer.ShaderManager; import net.minecraft.resources.Identifier; -import net.minecraft.server.packs.resources.Resource; -import net.minecraft.server.packs.resources.ResourceManager; -import net.minecraft.util.StringUtil; -import org.jspecify.annotations.Nullable; -import org.lwjgl.opengl.GL32; -import org.lwjgl.opengl.GL43; -import java.io.*; -import java.lang.reflect.Field; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.util.List; import java.util.OptionalDouble; import java.util.OptionalInt; import java.util.function.Supplier; -import static com.ibm.icu.impl.ValidIdentifiers.Datatype.x; - /** * Renders a UV colored quad * to the center of the screen to confirm DH's @@ -120,7 +92,7 @@ public class McTestRenderer implements IMcTestRenderer this.vertexFormat = VertexFormat.builder() .add("vPosition", DhVertexFormat.SCREEN_POS) - .add("vColor", DhVertexFormat.RGBA_COLOR) + .add("vColor", DhVertexFormat.RGBA_FLOAT_COLOR) .build(); //int breakpointOne = 0; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java new file mode 100644 index 000000000..6db42dea3 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java @@ -0,0 +1,63 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; + +import java.nio.ByteBuffer; +import java.util.function.Supplier; + +public class VertexBufferWrapper implements IVertexBufferWrapper +{ + + public GpuBuffer vboGpuBuffer = null; + public int vertexCount = -1; + public boolean uploaded = false; + + + @Override + public int getVertexCount() { return this.vertexCount ;} + + + + //========// + // render // + //========// + //region + + @Override + public void upload(ByteBuffer buffer, int vertexCount) + { + this.vertexCount = vertexCount; + this.uploaded = true; + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + Supplier labelSupplier = () -> "distantHorizons:McLodRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int byteSize = (buffer.limit() - buffer.position()); + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, byteSize); + + { + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, byteSize); + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + } + + @Override + public void close() + { + if (vboGpuBuffer != null) + this.vboGpuBuffer.close(); + } + + + + //endregion + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 9f4a935d3..5f38f083f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.common.renderTest.McFadeRenderer; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.McTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; @@ -39,6 +40,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLW import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; /** @@ -78,6 +80,7 @@ public class DependencySetup { SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFadeRenderer.class, McFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index b217242ff..6b10976d2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,6 +24,7 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; +import com.seibel.distanthorizons.common.renderTest.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; @@ -36,6 +37,7 @@ import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.IBatchGeneratorEnvironmentWrapper; @@ -355,4 +357,10 @@ public class WrapperFactory implements IWrapperFactory return message.toString(); } + + public IVertexBufferWrapper createVboWrapper() + { + return new VertexBufferWrapper(); + } + } diff --git a/coreSubProjects b/coreSubProjects index 9f483ee07..3e80961d1 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 9f483ee07a78dcfb00744f623761efed65c24b9c +Subproject commit 3e80961d18d3099cb55840fd464090ac4d797c82 From b0d325fd1414acce264c5741dd5f79631375cac7 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sat, 28 Feb 2026 08:13:59 -0600 Subject: [PATCH 09/72] minor render cleanup --- .../common/renderTest/McFadeRenderer.java | 2 +- .../common/renderTest/McLodRenderer.java | 285 ++++++------------ .../renderTest/VertexBufferWrapper.java | 6 +- coreSubProjects | 2 +- 4 files changed, 107 insertions(+), 188 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java index 051ec9511..1a1c6d07e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -102,7 +102,7 @@ public class McFadeRenderer implements IMcFadeRenderer pipelineBuilder.withDepthWrite(false); pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); pipelineBuilder.withColorWrite(true); - //builder.withBlend(BlendFunction.OVERLAY); + pipelineBuilder.withoutBlend(); pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index f3c9274d4..414a27cc8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -3,6 +3,8 @@ package com.seibel.distanthorizons.common.renderTest; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; @@ -62,6 +64,13 @@ public class McLodRenderer implements IMcLodRenderer private RenderPipeline transparentPipeline; private boolean init = false; + private GpuBuffer indexBuffer; + + private GpuBuffer fragUniformBuffer; + private GpuBuffer vertUniformBuffer; + + private GpuTexture depthTexture; + //=============// @@ -71,7 +80,16 @@ public class McLodRenderer implements IMcLodRenderer private McLodRenderer() { - + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SHORT_POS) + .add("paddingOne", DhVertexFormat.BYTE_PAD) + .add("light", DhVertexFormat.LIGHT) + .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR) + .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL) + .add("irisNormal", DhVertexFormat.IRIS_NORMAL) + .add("paddingTwo", DhVertexFormat.BYTE_PAD) + .add("paddingThree", DhVertexFormat.BYTE_PAD) // padding is to make sure the format is a multiple of 4 + .build(); } private void tryInit() @@ -93,20 +111,6 @@ public class McLodRenderer implements IMcLodRenderer CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SHORT_POS) //.add(ELEMENT_POSITION) - .add("paddingOne", DhVertexFormat.BYTE_PAD) //.add(ELEMENT_BYTE_PADDING) - .add("light", DhVertexFormat.LIGHT)//.add(ELEMENT_LIGHT) - .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR)//.add(ELEMENT_COLOR) - .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL)//.add(ELEMENT_IRIS_MATERIAL_INDEX) - .add("irisNormal", DhVertexFormat.IRIS_NORMAL)//.add(ELEMENT_IRIS_NORMAL_INDEX) - .add("paddingTwo", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) - .add("paddingThree", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) // padding is to make sure the format is a multiple of 4 - .build(); - - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(true); @@ -143,135 +147,26 @@ public class McLodRenderer implements IMcLodRenderer } - /** - * There's an Std180Builder and Std180SizeCalculator, if you missed them. Ensure the ubo in the shader is marked std180. - * These help keep alignment rules in check - */ - private static ByteBuffer setUniform(ByteBuffer oldBuffer, Mat4f matrix) - { - return setUniform(oldBuffer, "Mat4f", (buffer) -> - { - FloatBuffer floatBuffer = buffer.asFloatBuffer(); - matrix.store(floatBuffer); - }); - } - private static ByteBuffer setUniform(ByteBuffer oldBuffer, DhApiVec3f vector) - { - return setUniform(oldBuffer, "Vec3f", (buffer) -> - { - FloatBuffer floatBuffer = buffer.asFloatBuffer(); - floatBuffer - .put(vector.x) - .put(vector.y) - .put(vector.z) - .put(0f); - }); - } - private static ByteBuffer setUniform(ByteBuffer oldBuffer, boolean value) - { - return setUniform(oldBuffer, "boolean", (buffer) -> - { - IntBuffer intBuffer = buffer.asIntBuffer(); - intBuffer.put(value ? 1 : 0); - }); - } - private static ByteBuffer setUniform(ByteBuffer oldBuffer, float value) - { - return setUniform(oldBuffer, "float", (buffer) -> - { - FloatBuffer floatBuffer = buffer.asFloatBuffer(); - floatBuffer.put(value); - }); - } - private static ByteBuffer setUniform(ByteBuffer oldBuffer, int value) - { - return setUniform(oldBuffer, "int", (buffer) -> - { - IntBuffer intBuffer = buffer.asIntBuffer(); - intBuffer.put(value); - }); - } - private static ByteBuffer setUniform(ByteBuffer oldBuffer, String uploadType, Consumer modifyFunc) - { - int lengthInBytes; - switch (uploadType) - { - case "Mat4f": - lengthInBytes = 4 * 4 * Float.BYTES; - break; - case "float": - lengthInBytes = Float.BYTES; - break; - case "Vec3f": - lengthInBytes = 4 * Float.BYTES; - break; - case "int": - case "boolean": - lengthInBytes = Integer.BYTES; - break; - - default: - throw new UnsupportedOperationException("No known type ["+uploadType+"]"); - } - - - // buffer to upload data - ByteBuffer newBuffer = ByteBuffer.allocateDirect(oldBuffer.capacity() + lengthInBytes); - newBuffer.order(ByteOrder.nativeOrder()); - newBuffer.put(oldBuffer); - modifyFunc.accept(newBuffer); - newBuffer.rewind(); - - return newBuffer; - } - - private static GpuBuffer finalizeUniformBuffer(String uniformName, ByteBuffer buffer, GpuBuffer vboGpuBuffer) + private static GpuBuffer createUniformBuffer(String uniformName, int size, GpuBuffer vboGpuBuffer) { GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - // create VBO if needed if (vboGpuBuffer == null - || vboGpuBuffer.size() < buffer.capacity()) + || vboGpuBuffer.size() < size) { // GpuBuffer.USAGE_UNIFORM = 128 int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, buffer.capacity()); + vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, size); } - int offset = 0; - GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, offset, buffer.capacity()); - commandEncoder.writeToBuffer(bufferSlice, buffer); - return vboGpuBuffer; } - private GpuBuffer indexBuffer; - - private GpuBuffer fragUniformBuffer; - private GpuBuffer vertUniformBuffer; - - private GpuTexture depthTexture; - //endregion @Override - public int getVertexSize() - { - VertexFormat format = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SHORT_POS) //.add(ELEMENT_POSITION) - .add("paddingOne", DhVertexFormat.BYTE_PAD) //.add(ELEMENT_BYTE_PADDING) - .add("light", DhVertexFormat.LIGHT)//.add(ELEMENT_LIGHT) - .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR)//.add(ELEMENT_COLOR) - .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL)//.add(ELEMENT_IRIS_MATERIAL_INDEX) - .add("irisNormal", DhVertexFormat.IRIS_NORMAL)//.add(ELEMENT_IRIS_NORMAL_INDEX) - .add("paddingTwo", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) - .add("paddingThree", DhVertexFormat.BYTE_PAD)//.add(ELEMENT_BYTE_PADDING) // padding is to make sure the format is a multiple of 4 - .build(); - - return format.getVertexSize(); - } + public int getVertexSize() { return this.vertexFormat.getVertexSize(); } @@ -280,17 +175,6 @@ public class McLodRenderer implements IMcLodRenderer //========// //region - //@Override - //public void fillUniformData() - //{ - // - //} - //@Override - //public void setModelOffsetPos() - //{ - // - //} - @Override public void render( DhApiRenderParam renderEventParam, @@ -308,68 +192,104 @@ public class McLodRenderer implements IMcLodRenderer - profiler.push("set vert uniforms"); { - ByteBuffer buffer = ByteBuffer.allocateDirect(0); - buffer.order(ByteOrder.nativeOrder()); - - buffer = setUniform(buffer, false); // "uIsWhiteWorld" - - buffer = setUniform(buffer, false); // spacer 1 - buffer = setUniform(buffer, false); // spacer 2 - buffer = setUniform(buffer, false); // spacer 3 + // create data // Mat4f combinedMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); combinedMatrix.multiply(renderEventParam.dhModelViewMatrix); - buffer = setUniform(buffer, combinedMatrix); // uCombinedMatrix - buffer = setUniform(buffer, modelOffset); // uModelOffset - buffer = setUniform(buffer, renderEventParam.worldYOffset); // uWorldYOffset - buffer = setUniform(buffer, 0.01f); // uMircoOffset // 0.01 block offset - - float curveRatio = Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.get(); - if (curveRatio < -1.0f || curveRatio > 1.0f) + float earthCurveRatio = Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.get(); + if (earthCurveRatio < -1.0f || earthCurveRatio > 1.0f) { - curveRatio = /*6371KM*/ 6371000.0f / curveRatio; + earthCurveRatio = /*6371KM*/ 6371000.0f / earthCurveRatio; } else { // disable curvature if the config value is between -1 and 1 - curveRatio = 0.0f; + earthCurveRatio = 0.0f; } - buffer = setUniform(buffer, curveRatio); // uEarthRadius - - this.vertUniformBuffer = finalizeUniformBuffer("vertUniformBlock", buffer, this.vertUniformBuffer); + + + // upload data // + + int uniformBufferSize = new Std140SizeCalculator() + .putInt() // uIsWhiteWorld + + .putFloat() // uWorldYOffset + .putFloat() // uMircoOffset + .putFloat() // uEarthRadius + + .putVec3() // uModelOffset + + .putMat4f() // uCombinedMatrix + .get(); + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putInt(0) // uIsWhiteWorld + + .putFloat((float)renderEventParam.worldYOffset) // uWorldYOffset + .putFloat(0.01f) // uMircoOffset // 0.01 block offset + .putFloat(earthCurveRatio) // uEarthRadius + + .putVec3(modelOffset.x, modelOffset.y, modelOffset.z) // uModelOffset + + .putMat4f(combinedMatrix.createJomlMatrix()) // uCombinedMatrix + .get(); + + this.vertUniformBuffer = createUniformBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } profiler.popPush("set frag uniforms"); { - ByteBuffer buffer = ByteBuffer.allocateDirect(0); - buffer.order(ByteOrder.nativeOrder()); - - - // Clip Uniform + int uniformBufferSize = new Std140SizeCalculator() + .putFloat() // uClipDistance + .putFloat() // uNoiseIntensity + .putInt() // uNoiseSteps + .putInt() // uNoiseDropoff + .putInt() // uDitherDhRendering + .putInt() // uNoiseEnabled + .get(); + + + // create data // + float dhNearClipDistance = RenderUtil.getNearClipPlaneInBlocks(); if (!Config.Client.Advanced.Debugging.lodOnlyMode.get()) { // this added value prevents the near clip plane and discard circle from touching, which looks bad dhNearClipDistance += 16f; } - buffer = setUniform(buffer, dhNearClipDistance); // "uClipDistance" - - // Noise Uniforms - buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.enableNoiseTexture.get()); // "uNoiseEnabled" - buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseSteps.get()); // "uNoiseSteps" - buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseIntensity.get()); // "uNoiseIntensity" - buffer = setUniform(buffer, Config.Client.Advanced.Graphics.NoiseTexture.noiseDropoff.get()); // "uNoiseDropoff" - buffer = setUniform(buffer, Config.Client.Advanced.Graphics.Quality.ditherDhFade.get()); // "uDitherDhRendering" - - this.fragUniformBuffer = finalizeUniformBuffer("fragUniformBlock", buffer, this.fragUniformBuffer); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putFloat(dhNearClipDistance) // uClipDistance + .putFloat(Config.Client.Advanced.Graphics.NoiseTexture.noiseIntensity.get()) // uNoiseIntensity + .putInt(Config.Client.Advanced.Graphics.NoiseTexture.noiseSteps.get()) // uNoiseSteps + .putInt(Config.Client.Advanced.Graphics.NoiseTexture.noiseDropoff.get()) // uNoiseDropoff + .putInt(Config.Client.Advanced.Graphics.Quality.ditherDhFade.get() ? 1 : 0) // uDitherDhRendering + .putInt(Config.Client.Advanced.Graphics.NoiseTexture.enableNoiseTexture.get() ? 1 : 0) // uNoiseEnabled + .get() + ; + + this.fragUniformBuffer = createUniformBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); } - profiler.popPush("create index buffer"); + // create index buffer { if (this.indexBuffer == null) { @@ -378,8 +298,8 @@ public class McLodRenderer implements IMcLodRenderer // create VBO if needed - if (indexBuffer == null - || indexBuffer.size() < buffer.capacity()) + if (this.indexBuffer == null + || this.indexBuffer.size() < buffer.capacity()) { // GpuBuffer.USAGE_UNIFORM = 128 // GpuBuffer.USAGE_INDEX = 64 @@ -393,7 +313,7 @@ public class McLodRenderer implements IMcLodRenderer } } - // depth text + // depth texture if (this.depthTexture == null || this.depthTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() || this.depthTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) @@ -440,8 +360,6 @@ public class McLodRenderer implements IMcLodRenderer renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - //pipelineBuilder.withSampler("uLightMap"); - //boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); //if (renderWireframe) @@ -494,11 +412,8 @@ public class McLodRenderer implements IMcLodRenderer renderPass.drawIndexed( /*indexStart*/ 0, /*firstIndex*/0, - /*indexCount*/ - (int)(bufferWrapper.vertexCount * 1.5), // convert vertex count to index count // TODO fix me! - //LodBufferContainer.MAX_QUADS_PER_BUFFER, + /*indexCount*/bufferWrapper.indexCount, /*instanceCount*/1); - } catch (IllegalStateException e) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java index 6db42dea3..269d4f554 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java @@ -15,6 +15,7 @@ public class VertexBufferWrapper implements IVertexBufferWrapper public GpuBuffer vboGpuBuffer = null; public int vertexCount = -1; + public int indexCount = -1; public boolean uploaded = false; @@ -32,6 +33,7 @@ public class VertexBufferWrapper implements IVertexBufferWrapper public void upload(ByteBuffer buffer, int vertexCount) { this.vertexCount = vertexCount; + this.indexCount = (int)(vertexCount * 1.5); // TODO why multiply by 1.5? this.uploaded = true; @@ -52,8 +54,10 @@ public class VertexBufferWrapper implements IVertexBufferWrapper @Override public void close() { - if (vboGpuBuffer != null) + if (this.vboGpuBuffer != null) + { this.vboGpuBuffer.close(); + } } diff --git a/coreSubProjects b/coreSubProjects index 3e80961d1..c6a435571 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 3e80961d18d3099cb55840fd464090ac4d797c82 +Subproject commit c6a43557185d068ef0c0f35c60235d275dbe4960 From 224a5449ed76507cd4d8d2d27cb80c1b49683b37 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sat, 28 Feb 2026 11:35:09 -0600 Subject: [PATCH 10/72] re-Add vanilla fade --- .../common/renderTest/McApplyRenderer.java | 248 ++++++++++++++++++ .../common/renderTest/McCopyRenderer.java | 223 ++++++++++++++++ .../common/renderTest/McFadeRenderer.java | 187 +++++++++++-- .../common/renderTest/McLodRenderer.java | 105 +++----- .../common/renderTest/UniformHandler.java | 26 ++ coreSubProjects | 2 +- 6 files changed, 707 insertions(+), 84 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java new file mode 100644 index 000000000..77dc8defe --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java @@ -0,0 +1,248 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO ??? + */ +public class McApplyRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McApplyRenderer INSTANCE = new McApplyRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer vboGpuBuffer; + + + //=============// + // constructor // + //=============// + //region + + private McApplyRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:apply_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "apply/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "apply/frag")); + + pipelineBuilder.withSampler("uDhColorTexture"); + pipelineBuilder.withSampler("uDhDepthTexture"); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McApplyRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + if (McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // create a render pass + { + Supplier debugLabelSupplier = () -> "distantHorizons:McApplyRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); + } + + // bind depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java new file mode 100644 index 000000000..1dd4242a4 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java @@ -0,0 +1,223 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO ??? + */ +public class McCopyRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McCopyRenderer INSTANCE = new McCopyRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer vboGpuBuffer; + + + //=============// + // constructor // + //=============// + //region + + private McCopyRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:copy_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/frag")); + + pipelineBuilder.withSampler("uCopyTexture"); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McCopyRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render(GpuTexture sourceTexture, GpuTexture destinationTexture) + { + this.tryInit(); + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // create a render pass + { + Supplier debugLabelSupplier = () -> "distantHorizons:McCopyRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(destinationTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(sourceTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uCopyTexture", textureView, gpuSampler); + } + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java index 1a1c6d07e..119b99cb3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java @@ -21,23 +21,29 @@ package com.seibel.distanthorizons.common.renderTest; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -63,8 +69,12 @@ public class McFadeRenderer implements IMcFadeRenderer private RenderPipeline pipeline; private boolean init = false; + private GpuBuffer fragUniformBuffer; + private GpuBuffer vboGpuBuffer; + public GpuTexture fadeColorTexture; + //=============// @@ -74,7 +84,9 @@ public class McFadeRenderer implements IMcFadeRenderer private McFadeRenderer() { - + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); } private void tryInit() @@ -91,10 +103,6 @@ public class McFadeRenderer implements IMcFadeRenderer CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) - .build(); - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { @@ -107,9 +115,15 @@ public class McFadeRenderer implements IMcFadeRenderer pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/frag")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vanilla_fade")); + + pipelineBuilder.withSampler("uMcDepthTexture"); + pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); pipelineBuilder.withSampler("uDhDepthTexture"); + pipelineBuilder.withSampler("uDhColorTexture"); + + pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); } @@ -160,22 +174,121 @@ public class McFadeRenderer implements IMcFadeRenderer //========// //region - public void render() + @Override + public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) { this.tryInit(); + if (McLodRenderer.INSTANCE.dhDepthTexture == null + || McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + // textures + if (this.fadeColorTexture == null + || this.fadeColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.fadeColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + { + if (this.fadeColorTexture != null) + { + this.fadeColorTexture.close(); + } + + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.fadeColorTexture = gpuDevice.createTexture("FadeColorTexture", + usage, + TextureFormat.RGBA8, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); + } + + + { + int uniformBufferSize = new Std140SizeCalculator() + .putInt() // uOnlyRenderLods + .putFloat() // uStartFadeBlockDistance + .putFloat() // uEndFadeBlockDistance + .putFloat() // uMaxLevelHeight + .putMat4f() // uDhInvMvmProj + .putMat4f() // uMcInvMvmProj + .get(); + + + // create data // + + float dhNearClipDistance = RenderUtil.getNearClipPlaneInBlocks(); + // this added value prevents the near clip plane and discard circle from touching, which looks bad + dhNearClipDistance += 16f; + + // measured in blocks + // these multipliers in James' tests should provide a fairly smooth transition + // without having underdraw issues + float fadeStartDistance = dhNearClipDistance * 1.5f; + float fadeEndDistance = dhNearClipDistance * 1.9f; + + + Mat4f inverseMcModelViewProjectionMatrix = new Mat4f(mcProjectionMatrix); + inverseMcModelViewProjectionMatrix.multiply(mcModelViewMatrix); + inverseMcModelViewProjectionMatrix.invert(); + Mat4f inverseMcMvmProjMatrix = inverseMcModelViewProjectionMatrix; + + + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + + Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); + inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); + inverseDhModelViewProjectionMatrix.invert(); + Mat4f inverseDhMvmProjMatrix = inverseDhModelViewProjectionMatrix; + + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putInt(Config.Client.Advanced.Debugging.lodOnlyMode.get() ? 1 : 0) // uOnlyRenderLods + .putFloat(fadeStartDistance) // uStartFadeBlockDistance + .putFloat(fadeEndDistance) // uEndFadeBlockDistance + .putFloat(level.getMaxHeight()) // uMaxLevelHeight + .putMat4f(inverseDhMvmProjMatrix.createJomlMatrix()) // uDhInvMvmProj + .putMat4f(inverseMcMvmProjMatrix.createJomlMatrix()) // uMcInvMvmProj + .get() + ; + + this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + this.renderFadeToTexture(); + McCopyRenderer.INSTANCE.render(this.fadeColorTexture, Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + + } + + private void renderFadeToTexture() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + // create a render pass Supplier debugLabelSupplier = () -> "distantHorizons:McFadeRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + GpuTextureView colorTexture = gpuDevice.createTextureView(this.fadeColorTexture); OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null;//gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + GpuTextureView depthTexture = null; OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); try (RenderPass renderPass = commandEncoder.createRenderPass( @@ -192,9 +305,32 @@ public class McFadeRenderer implements IMcFadeRenderer { // bind MC depth texture { - GpuTexture bindDepthTexture = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); - - GpuTextureView textureView = gpuDevice.createTextureView(bindDepthTexture); + GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uMcDepthTexture", textureView, gpuSampler); + } + + // bind MC color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uCombinedMcDhColorTexture", textureView, gpuSampler); + } + + + // bind DH depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); GpuSampler gpuSampler = gpuDevice.createSampler( AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter @@ -204,15 +340,27 @@ public class McFadeRenderer implements IMcFadeRenderer renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); } - // bind VBO + // bind DH color texture { - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); } + + + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + // set pipeline - { - renderPass.setPipeline(this.pipeline); - } + renderPass.setPipeline(this.pipeline); } // draw render pass @@ -224,6 +372,7 @@ public class McFadeRenderer implements IMcFadeRenderer } } + //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index 414a27cc8..7aecbcb2b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -16,7 +16,6 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.mojang.blaze3d.vertex.VertexFormatElement; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.core.config.Config; @@ -26,6 +25,7 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.glObject.GLEnums; import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; @@ -40,11 +40,8 @@ import org.lwjgl.system.MemoryUtil; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.nio.FloatBuffer; -import java.nio.IntBuffer; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Consumer; import java.util.function.Supplier; /** @@ -69,7 +66,8 @@ public class McLodRenderer implements IMcLodRenderer private GpuBuffer fragUniformBuffer; private GpuBuffer vertUniformBuffer; - private GpuTexture depthTexture; + public GpuTexture dhDepthTexture; + public GpuTexture dhColorTexture; @@ -102,11 +100,6 @@ public class McLodRenderer implements IMcLodRenderer - //GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); - //GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); - - - GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); @@ -147,22 +140,6 @@ public class McLodRenderer implements IMcLodRenderer } - private static GpuBuffer createUniformBuffer(String uniformName, int size, GpuBuffer vboGpuBuffer) - { - GpuDevice gpuDevice = RenderSystem.getDevice(); - - // create VBO if needed - if (vboGpuBuffer == null - || vboGpuBuffer.size() < size) - { - // GpuBuffer.USAGE_UNIFORM = 128 - int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, size); - } - - return vboGpuBuffer; - } - //endregion @Override @@ -239,7 +216,7 @@ public class McLodRenderer implements IMcLodRenderer .putMat4f(combinedMatrix.createJomlMatrix()) // uCombinedMatrix .get(); - this.vertUniformBuffer = createUniformBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); + this.vertUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); commandEncoder.writeToBuffer(bufferSlice, buffer); @@ -283,7 +260,7 @@ public class McLodRenderer implements IMcLodRenderer .get() ; - this.fragUniformBuffer = createUniformBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); commandEncoder.writeToBuffer(bufferSlice, buffer); @@ -313,23 +290,31 @@ public class McLodRenderer implements IMcLodRenderer } } - // depth texture - if (this.depthTexture == null - || this.depthTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.depthTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + // textures + if (this.dhDepthTexture == null + || this.dhDepthTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.dhDepthTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) { - if (this.depthTexture != null) + if (this.dhDepthTexture != null) { - this.depthTexture.close(); + this.dhDepthTexture.close(); + this.dhColorTexture.close(); } - int usage = 8 | 32 | 128; - this.depthTexture = gpuDevice.createTexture("DhDepthTexture", + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.dhDepthTexture = gpuDevice.createTexture("DhDepthTexture", usage, TextureFormat.DEPTH32, MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), 1, 1 ); + this.dhColorTexture = gpuDevice.createTexture("DhColorTexture", + usage, + TextureFormat.RGBA8, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); } @@ -341,8 +326,8 @@ public class McLodRenderer implements IMcLodRenderer OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); try ( - GpuTextureView colorTextureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); - GpuTextureView depthTextureView = gpuDevice.createTextureView(this.depthTexture); + GpuTextureView colorTextureView = gpuDevice.createTextureView(this.dhColorTexture); + GpuTextureView depthTextureView = gpuDevice.createTextureView(this.dhDepthTexture); RenderPass renderPass = commandEncoder.createRenderPass( debugLabelSupplier, colorTextureView, @@ -361,30 +346,6 @@ public class McLodRenderer implements IMcLodRenderer renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - //boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); - //if (renderWireframe) - //{ - // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); - // GLMC.disableFaceCulling(); - //} - //else - //{ - // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - // GLMC.enableFaceCulling(); - //} - // - //if (!opaquePass) - //{ - // GLMC.enableBlend(); - // GLMC.enableDepthTest(); - // GL32.glBlendEquation(GL32.GL_FUNC_ADD); - // GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); - //} - //else - //{ - // GLMC.disableBlend(); - //} - profiler.popPush("set pipeline"); @@ -431,14 +392,30 @@ public class McLodRenderer implements IMcLodRenderer profiler.pop(); } + @Override + public void applyToMcTexture() { McApplyRenderer.INSTANCE.render(); } + + @Override public void clearDepth() { GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - if (this.depthTexture != null) + if (this.dhDepthTexture != null) { - commandEncoder.clearDepthTexture(this.depthTexture, 1.0f); + commandEncoder.clearDepthTexture(this.dhDepthTexture, 1.0f); + } + } + + @Override + public void clearColor() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + if (this.dhColorTexture != null) + { + commandEncoder.clearColorTexture(this.dhColorTexture, ColorUtil.argbToInt(1, 1, 1, 1)); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java new file mode 100644 index 000000000..dd4c73a00 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java @@ -0,0 +1,26 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; + +public class UniformHandler +{ + + public static GpuBuffer createBuffer(String uniformName, int size, GpuBuffer vboGpuBuffer) + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + + // create VBO if needed + if (vboGpuBuffer == null + || vboGpuBuffer.size() < size) + { + // GpuBuffer.USAGE_UNIFORM = 128 + int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, size); + } + + return vboGpuBuffer; + } + +} diff --git a/coreSubProjects b/coreSubProjects index c6a435571..3f509be19 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit c6a43557185d068ef0c0f35c60235d275dbe4960 +Subproject commit 3f509be195bad4dc3988c8805f5bfb56d375a9dc From dedcc875d2ae66c9d643f7ee57868859bdc128e2 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sat, 28 Feb 2026 12:13:38 -0600 Subject: [PATCH 11/72] re-add lighting --- .../common/renderTest/DhVertexFormat.java | 7 +++++- .../common/renderTest/McLodRenderer.java | 24 ++++++++++++++----- .../minecraft/MinecraftRenderWrapper.java | 11 +++++++++ .../common/wrappers/misc/LightMapWrapper.java | 8 +++++++ coreSubProjects | 2 +- .../mixins/client/MixinLightTexture.java | 5 ++-- .../mixins/client/MixinLightTexture.java | 5 ++-- 7 files changed, 50 insertions(+), 12 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java index 362a60d6a..cd41a46db 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java @@ -1,7 +1,11 @@ package com.seibel.distanthorizons.common.renderTest; import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; +/** + * @see LodQuadBuilder + */ public class DhVertexFormat { public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); @@ -9,7 +13,8 @@ public class DhVertexFormat public static final VertexFormatElement SHORT_POS = VertexFormatElement.register(/*id*/9, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); public static final VertexFormatElement BYTE_PAD = VertexFormatElement.register(/*id*/10, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); - public static final VertexFormatElement LIGHT = VertexFormatElement.register(/*id*/11, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + /** contains light and micro-offset */ + public static final VertexFormatElement META = VertexFormatElement.register(/*id*/11, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.GENERIC, /*count*/ 1); public static final VertexFormatElement RGBA_UBYTE_COLOR = VertexFormatElement.register(/*id*/12, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.COLOR, /*count*/ 4); public static final VertexFormatElement IRIS_MATERIAL = VertexFormatElement.register(/*id*/13, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); public static final VertexFormatElement IRIS_NORMAL = VertexFormatElement.register(/*id*/14, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index 7aecbcb2b..a629028b0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -18,6 +18,7 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -25,6 +26,7 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.glObject.GLEnums; import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -80,8 +82,7 @@ public class McLodRenderer implements IMcLodRenderer { this.vertexFormat = VertexFormat.builder() .add("vPosition", DhVertexFormat.SHORT_POS) - .add("paddingOne", DhVertexFormat.BYTE_PAD) - .add("light", DhVertexFormat.LIGHT) + .add("meta", DhVertexFormat.META) .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR) .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL) .add("irisNormal", DhVertexFormat.IRIS_NORMAL) @@ -116,7 +117,7 @@ public class McLodRenderer implements IMcLodRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/frag")); - //pipelineBuilder.withSampler("uLightMap"); // TODO + pipelineBuilder.withSampler("uLightMap"); pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); @@ -154,7 +155,7 @@ public class McLodRenderer implements IMcLodRenderer @Override public void render( - DhApiRenderParam renderEventParam, + RenderParams renderEventParam, boolean opaquePass, DhApiVec3f modelOffset, IVertexBufferWrapper[] bufferList, @@ -338,8 +339,19 @@ public class McLodRenderer implements IMcLodRenderer //renderPass.popDebugGroup(); - //renderPass.bindTexture("uLightMap", ); - + // bind MC color texture + { + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + + GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uLightMap", textureView, gpuSampler); + } renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java index f038fffa4..d2d685c1b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java @@ -25,6 +25,7 @@ import java.util.concurrent.ConcurrentHashMap; import com.mojang.blaze3d.pipeline.RenderTarget; import com.mojang.blaze3d.platform.NativeImage; +import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.api.enums.config.EDhApiLodShading; import com.seibel.distanthorizons.common.wrappers.McObjectConverter; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; @@ -488,6 +489,16 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper()); wrapper.setLightmapId(tetxureId); } + public void setLightmapGpuTexture(GpuTexture gpuTexture, IClientLevelWrapper level) + { + // Using ClientLevelWrapper as the key would be better, but we don't have a consistent way to create the same + // object for the same MC level and/or the same hash, + // so this will have to do for now + IDimensionTypeWrapper dimensionType = level.getDimensionType(); + + LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper()); + wrapper.setLightmapGpuTexture(gpuTexture); + } @Override public float getShade(EDhDirection lodDirection) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 5569a5006..9d3f57f59 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; +import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; @@ -38,6 +39,7 @@ public class LightMapWrapper implements ILightMapWrapper private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private int textureId = 0; + public GpuTexture gpuTexture = null; @@ -99,6 +101,12 @@ public class LightMapWrapper implements ILightMapWrapper this.textureId = minecraftLightmapTextureId; } + public void setLightmapGpuTexture(GpuTexture gpuTexture) + { + // just use the MC texture ID + this.gpuTexture = gpuTexture; + } + //endregion diff --git a/coreSubProjects b/coreSubProjects index 3f509be19..200e089a3 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 3f509be195bad4dc3988c8805f5bfb56d375a9dc +Subproject commit 200e089a3336ea61c4012f762c6e19d6c5c6c1bb diff --git a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java index 7b5814da9..cd87569d1 100644 --- a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java +++ b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java @@ -94,8 +94,9 @@ public class MixinLightTexture #elif MC_VER < MC_1_21_5 this.renderWrapper.setLightmapId(this.target.getColorTextureId(), clientLevel); #else - GlTexture glTexture = (GlTexture) this.texture; - this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + //GlTexture glTexture = (GlTexture) this.texture; + //this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + this.renderWrapper.setLightmapGpuTexture(this.texture, clientLevel); #endif } diff --git a/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java b/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java index aec713f00..ab6b806ef 100644 --- a/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java +++ b/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java @@ -86,8 +86,9 @@ public class MixinLightTexture GlTexture glTexture = (GlTexture) this.texture; renderWrapper.setLightmapId(glTexture.glId(), clientLevel); #else - int id = NeoforgeTextureUnwrapper.getGlTextureIdFromGpuTexture(this.texture); - renderWrapper.setLightmapId(id, clientLevel); + //int id = NeoforgeTextureUnwrapper.getGlTextureIdFromGpuTexture(this.texture); + //renderWrapper.setLightmapId(id, clientLevel); + renderWrapper.setLightmapGpuTexture(this.texture, clientLevel); #endif } From f4171ffca1e816de06e30d9d5a36854d569c0ffe Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sun, 1 Mar 2026 16:30:01 -0600 Subject: [PATCH 12/72] rename vertex element --- .../distanthorizons/common/renderTest/DhVertexFormat.java | 2 +- .../distanthorizons/common/renderTest/McLodRenderer.java | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java index cd41a46db..1bbb751c8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java @@ -11,7 +11,7 @@ public class DhVertexFormat public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); public static final VertexFormatElement RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); - public static final VertexFormatElement SHORT_POS = VertexFormatElement.register(/*id*/9, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + public static final VertexFormatElement SHORT_XYZ_POS = VertexFormatElement.register(/*id*/9, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); public static final VertexFormatElement BYTE_PAD = VertexFormatElement.register(/*id*/10, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); /** contains light and micro-offset */ public static final VertexFormatElement META = VertexFormatElement.register(/*id*/11, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.GENERIC, /*count*/ 1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index a629028b0..bd0f40e8f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -16,7 +16,6 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -35,7 +34,6 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRen import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; -import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import org.lwjgl.opengl.GL32; import org.lwjgl.system.MemoryUtil; @@ -81,7 +79,7 @@ public class McLodRenderer implements IMcLodRenderer private McLodRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SHORT_POS) + .add("vPosition", DhVertexFormat.SHORT_XYZ_POS) .add("meta", DhVertexFormat.META) .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR) .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL) @@ -339,7 +337,7 @@ public class McLodRenderer implements IMcLodRenderer //renderPass.popDebugGroup(); - // bind MC color texture + // bind MC Lightmap { LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; From ae6fa83c50531636be25b88f68ec8f1913b45f2f Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sun, 1 Mar 2026 19:33:00 -0600 Subject: [PATCH 13/72] generic object rendering --- .../common/renderTest/DhVertexFormat.java | 4 + .../renderTest/McGenericObjectRenderer.java | 648 +++++++++++++++ .../McGenericObjectRenderer_Textures.java | 779 ++++++++++++++++++ .../renderTest/McInstancedVboContainer.java | 392 +++++++++ .../McInstancedVboContainer_Textures.java | 277 +++++++ .../common/renderTest/McTestRenderer.java | 41 +- .../common/wrappers/WrapperFactory.java | 19 + coreSubProjects | 2 +- 8 files changed, 2122 insertions(+), 40 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java index 1bbb751c8..06b5dec3a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java @@ -19,5 +19,9 @@ public class DhVertexFormat public static final VertexFormatElement IRIS_MATERIAL = VertexFormatElement.register(/*id*/13, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); public static final VertexFormatElement IRIS_NORMAL = VertexFormatElement.register(/*id*/14, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + public static final VertexFormatElement FLOAT_XYZ_POS = VertexFormatElement.register(/*id*/15, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + public static final VertexFormatElement VEC3 = VertexFormatElement.register(/*id*/16, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.GENERIC, /*count*/ 3); + public static final VertexFormatElement IVEC3 = VertexFormatElement.register(/*id*/17, /*index*/0, VertexFormatElement.Type.INT, VertexFormatElement.Usage.GENERIC, /*count*/ 3); + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java new file mode 100644 index 000000000..6a0e58e94 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java @@ -0,0 +1,648 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericObjectRenderEvent; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderCleanupEvent; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderSetupEvent; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.logging.f3.F3Screen; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.render.renderer.generic.InstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.ModInfo; +import net.minecraft.resources.Identifier; + +import java.awt.*; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.ArrayList; +import java.util.Collection; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +/** + * Handles rendering generic groups of {@link DhApiRenderableBox}. + * + * @see IDhApiCustomRenderRegister + * @see DhApiRenderableBox + */ +public class McGenericObjectRenderer implements IMcGenericRenderer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); + + /** + * Can be used to troubleshoot the renderer. + * If enabled several debug objects will render around (0,150,0). + */ + public static final boolean RENDER_DEBUG_OBJECTS = false; + + private final ConcurrentHashMap boxGroupById = new ConcurrentHashMap<>(); + + + // rendering setup + private boolean init = false; + + private VertexFormat vertexFormat; + + private RenderPipeline opaquePipeline; + private RenderPipeline transparentPipeline; + + //private GpuBuffer boxVertexBuffer; + //private GpuBuffer boxIndexBuffer; + + private GpuBuffer vertUniformBuffer; + + + //=============// + // constructor // + //=============// + //region + + public McGenericObjectRenderer() { } + + public void init() + { + if (this.init) + { + return; + } + this.init = true; + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) + .add("aColor", DhVertexFormat.RGBA_UBYTE_COLOR) + .add("aMaterial", DhVertexFormat.IRIS_MATERIAL) + .build(); + + this.createPipelines(); + //this.createBuffers(); + + if (RENDER_DEBUG_OBJECTS) + { + this.addGenericDebugObjects(); + } + } + private void createPipelines() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(true); + pipelineBuilder.withDepthWrite(true); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:generic")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/frag")); + + pipelineBuilder.withSampler("uLightMap"); + + pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + } + + // opaque + { + pipelineBuilder.withoutBlend(); + this.opaquePipeline = pipelineBuilder.build(); + } + + // transparent + { + pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); + this.transparentPipeline = pipelineBuilder.build(); + } + + } + private void addGenericDebugObjects() + { + GenericRenderObjectFactory factory = GenericRenderObjectFactory.INSTANCE; + + + // single giant box + IDhApiRenderableBoxGroup singleGiantBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":CyanChunkBox", + new DhApiRenderableBox( + new DhApiVec3d(0,0,0), new DhApiVec3d(16,190,16), + new Color(Color.CYAN.getRed(), Color.CYAN.getGreen(), Color.CYAN.getBlue(), 125), + EDhApiBlockMaterial.WATER) + ); + singleGiantBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleGiantBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleGiantBoxGroup); + + + // single slender box + IDhApiRenderableBoxGroup singleTallBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":GreenBeacon", + new DhApiRenderableBox( + new DhApiVec3d(16,0,31), new DhApiVec3d(17,2000,32), + new Color(Color.GREEN.getRed(), Color.GREEN.getGreen(), Color.GREEN.getBlue(), 125), + EDhApiBlockMaterial.ILLUMINATED) + ); + singleTallBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleTallBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleTallBoxGroup); + + + // absolute box group + ArrayList absBoxList = new ArrayList<>(); + for (int i = 0; i < 18; i++) + { + absBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(i,150+i,24), new DhApiVec3d(1+i,151+i,25), + new Color(Color.ORANGE.getRed(), Color.ORANGE.getGreen(), Color.ORANGE.getBlue()), + EDhApiBlockMaterial.LAVA + ) + ); + } + IDhApiRenderableBoxGroup absolutePosBoxGroup = factory.createAbsolutePositionedGroup(ModInfo.NAME + ":OrangeStairs", absBoxList); + this.add(absolutePosBoxGroup); + + + // relative box group + ArrayList relBoxList = new ArrayList<>(); + for (int i = 0; i < 8; i+=2) + { + relBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(0,i,0), new DhApiVec3d(1,1+i,1), + new Color(Color.MAGENTA.getRed(), Color.MAGENTA.getGreen(), Color.MAGENTA.getBlue()), + EDhApiBlockMaterial.METAL + ) + ); + } + IDhApiRenderableBoxGroup relativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MovingMagentaGroup", + new DhApiVec3d(24, 140, 24), + relBoxList); + relativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d pos = relativePosBoxGroup.getOriginBlockPos(); + pos.x += event.partialTicks / 2; + pos.x %= 32; + relativePosBoxGroup.setOriginBlockPos(pos); + }); + this.add(relativePosBoxGroup); + + + // massive relative box group + ArrayList massRelBoxList = new ArrayList<>(); + for (int x = 0; x < 50*2; x+=2) + { + for (int z = 0; z < 50*2; z+=2) + { + massRelBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(-x, 0, -z), new DhApiVec3d(1-x, 1, 1-z), + new Color(Color.RED.getRed(), Color.RED.getGreen(), Color.RED.getBlue()), + EDhApiBlockMaterial.TERRACOTTA + ) + ); + } + } + IDhApiRenderableBoxGroup massRelativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MassRedGroup", + new DhApiVec3d(-25, 140, 0), + massRelBoxList); + massRelativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d blockPos = massRelativePosBoxGroup.getOriginBlockPos(); + blockPos.y += event.partialTicks / 4; + if (blockPos.y > 150f) + { + blockPos.y = 140f; + + Color newColor = (massRelativePosBoxGroup.get(0).color == Color.RED) ? Color.RED.darker() : Color.RED; + massRelativePosBoxGroup.forEach((box) -> { box.color = newColor; }); + massRelativePosBoxGroup.triggerBoxChange(); + } + + massRelativePosBoxGroup.setOriginBlockPos(blockPos); + }); + this.add(massRelativePosBoxGroup); + } + + //endregion + + + + //==============// + // registration // + //==============// + //region + + @Override + public void add(IDhApiRenderableBoxGroup iBoxGroup) throws IllegalArgumentException + { + if (!(iBoxGroup instanceof RenderableBoxGroup)) + { + throw new IllegalArgumentException("Box group must be of type ["+ RenderableBoxGroup.class.getSimpleName()+"], type received: ["+(iBoxGroup != null ? iBoxGroup.getClass() : "NULL")+"]."); + } + RenderableBoxGroup boxGroup = (RenderableBoxGroup) iBoxGroup; + + + long id = boxGroup.getId(); + if (this.boxGroupById.containsKey(id)) + { + throw new IllegalArgumentException("A box group with the ID [" + id + "] is already present."); + } + + this.boxGroupById.put(id, boxGroup); + } + + @Override + public IDhApiRenderableBoxGroup remove(long id) { return this.boxGroupById.remove(id); } + + public void clear() { this.boxGroupById.clear(); } + + //endregion + + + + //===========// + // rendering // + //===========// + //region + + /** + * @param renderingWithSsao + * if true that means this render call is happening before the SSAO pass + * and any objects rendered in this pass will have SSAO applied to them. + */ + @Override + public void render(RenderParams renderEventParam, IProfilerWrapper profiler, boolean renderingWithSsao) + { + //==============// + // render setup // + //==============// + //#region + + profiler.push("setup"); + + this.init(); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderSetupEvent.class, renderEventParam); + + Vec3d camPos = MC_RENDER.getCameraExactPosition(); + + //#endregion + + if (McLodRenderer.INSTANCE.dhColorTexture == null + || McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + + + //===========// + // rendering // + //===========// + //#region + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + Collection boxList = this.boxGroupById.values(); + for (RenderableBoxGroup boxGroup : boxList) + { + // validation // + + // shouldn't happen, but just in case + if (boxGroup == null) + { + continue; + } + + // skip boxes that shouldn't render this pass + if (boxGroup.ssaoEnabled != renderingWithSsao) + { + continue; + } + + profiler.popPush("render prep"); + boxGroup.preRender(renderEventParam); // called even if the group is inactive, so the group can be activate if desired + + // ignore inactive groups + if (!boxGroup.active) + { + continue; + } + + // allow API users to cancel this object's rendering + boolean cancelRendering = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericObjectRenderEvent.class, new DhApiBeforeGenericObjectRenderEvent.EventParam(renderEventParam, boxGroup)); + if (cancelRendering) + { + continue; + } + + // update instanced data if needed + { + boxGroup.tryUpdateInstancedDataAsync(); + + // skip groups that haven't been uploaded yet + if (boxGroup.instancedVbos.getState() != InstancedVboContainer.EState.RENDER) + { + continue; + } + } + + + DhApiRenderableBoxGroupShading shading = boxGroup.shading; + if (shading == null) + { + shading = DEFAULT_SHADING; + } + + // uniforms + { + int uniformBufferSize = new Std140SizeCalculator() + .putIVec3() // uOffsetChunk + .putVec3() // uOffsetSubChunk + .putIVec3() // uCameraPosChunk + .putVec3() // uCameraPosSubChunk + + .putVec3() // aTranslateChunk + .putVec3() // aTranslateSubChunk + + .putMat4f() // uProjectionMvm + .putInt() // uSkyLight + .putInt() // uBlockLight + + .putFloat() // uNorthShading + .putFloat() // uSouthShading + .putFloat() // uEastShading + .putFloat() // uWestShading + .putFloat() // uTopShading + .putFloat() // uBottomShading + .get(); + + + // create data // + + Mat4f projectionMvmMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); + projectionMvmMatrix.multiply(renderEventParam.dhModelViewMatrix); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putIVec3( + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + ) // uOffsetChunk + .putVec3( + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + ) // uOffsetSubChunk + .putIVec3( + LodUtil.getChunkPosFromDouble(camPos.x), + LodUtil.getChunkPosFromDouble(camPos.y), + LodUtil.getChunkPosFromDouble(camPos.z) + ) // uCameraPosChunk + .putVec3( + LodUtil.getSubChunkPosFromDouble(camPos.x), + LodUtil.getSubChunkPosFromDouble(camPos.y), + LodUtil.getSubChunkPosFromDouble(camPos.z) + ) // uCameraPosSubChunk + + .putMat4f(projectionMvmMatrix.createJomlMatrix()) // uProjectionMvm + .putInt(boxGroup.getSkyLight()) // uSkyLight + .putInt(boxGroup.getBlockLight()) // uBlockLight + + .putFloat(shading.north) + .putFloat(shading.south) + .putFloat(shading.east) + .putFloat(shading.west) + .putFloat(shading.top) + .putFloat(shading.bottom) + + .get() + ; + + this.vertUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + + + // render // + + profiler.popPush("rendering"); + profiler.push(boxGroup.getResourceLocationNamespace()); + profiler.push(boxGroup.getResourceLocationPath()); + + Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); + } + + profiler.pop(); // resource path + profiler.pop(); // resource namespace + + boxGroup.postRender(renderEventParam); + } + + //#endregion + + + + //==========// + // clean up // + //==========// + //region + + profiler.popPush("cleanup"); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderCleanupEvent.class, renderEventParam); + + profiler.pop(); + + //endregion + } + + //endregion + + + + //=====================// + // instanced rendering // + //=====================// + //region + + private void renderBoxGroupInstanced( + RenderPass renderPass, RenderParams renderEventParam, + RenderableBoxGroup boxGroup, Vec3d camPos, + IProfilerWrapper profiler) + { + // update instance data // + + profiler.push("vertex setup"); + + GpuDevice gpuDevice = RenderSystem.getDevice(); + + McInstancedVboContainer container = (McInstancedVboContainer) boxGroup.instancedVbos; + + + // bind MC Lightmap + { + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + + GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uLightMap", textureView, gpuSampler); + } + + + + // Bind instance data // + profiler.popPush("binding"); + + + renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); + + // set pipeline + renderPass.setPipeline(this.opaquePipeline); // TODO + renderPass.setIndexBuffer(container.indexGpuBuffer, VertexFormat.IndexType.INT); + + renderPass.setVertexBuffer(0, container.vboGpuBuffer); + + // Draw instanced + profiler.popPush("render"); + if (container.uploadedBoxCount > 0) + { + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/container.uploadedBoxCount * 24, // TODO? + /*instanceCount*/1); + + } + + profiler.pop(); + } + + //endregion + + + + //=========// + // F3 menu // + //=========// + //region + + public String getVboRenderDebugMenuString() + { + // get counts + int totalGroupCount = this.boxGroupById.size(); + int totalBoxCount = 0; + + int activeGroupCount = 0; + int activeBoxCount = 0; + + for (long key : this.boxGroupById.keySet()) + { + RenderableBoxGroup renderGroup = this.boxGroupById.get(key); + if (renderGroup.active) + { + activeGroupCount++; + activeBoxCount += renderGroup.size(); + } + totalBoxCount += renderGroup.size(); + } + + + return "Generic Obj #: " + F3Screen.NUMBER_FORMAT.format(activeGroupCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalGroupCount) + ", " + + "Cube #: " + F3Screen.NUMBER_FORMAT.format(activeBoxCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalBoxCount); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java new file mode 100644 index 000000000..176ff7975 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java @@ -0,0 +1,779 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.AddressMode; +import com.mojang.blaze3d.textures.FilterMode; +import com.mojang.blaze3d.textures.GpuSampler; +import com.mojang.blaze3d.textures.GpuTextureView; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericObjectRenderEvent; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderCleanupEvent; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderSetupEvent; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.logging.f3.F3Screen; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.render.renderer.generic.InstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.ModInfo; +import net.minecraft.resources.Identifier; +import org.lwjgl.system.MemoryUtil; + +import java.awt.*; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.ArrayList; +import java.util.Collection; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +/** + * Handles rendering generic groups of {@link DhApiRenderableBox}. + * + * @see IDhApiCustomRenderRegister + * @see DhApiRenderableBox + */ +public class McGenericObjectRenderer_Textures implements IMcGenericRenderer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); + + /** + * Can be used to troubleshoot the renderer. + * If enabled several debug objects will render around (0,150,0). + */ + public static final boolean RENDER_DEBUG_OBJECTS = false; + + /** A box from 0,0,0 to 1,1,1 */ + private static final float[] BOX_VERTICES = { + //region + // Pos x y z + + // min X, vertical face + 0, 0, 0, + 1, 0, 0, + 1, 1, 0, + 0, 1, 0, + // max X, vertical face + 0, 1, 1, + 1, 1, 1, + 1, 0, 1, + 0, 0, 1, + + // min Z, vertical face + 0, 0, 1, + 0, 0, 0, + 0, 1, 0, + 0, 1, 1, + // max Z, vertical face + 1, 0, 1, + 1, 1, 1, + 1, 1, 0, + 1, 0, 0, + + // min Y, horizontal face + 0, 0, 1, + 1, 0, 1, + 1, 0, 0, + 0, 0, 0, + // max Y, horizontal face + 0, 1, 1, + 1, 1, 1, + 1, 1, 0, + 0, 1, 0, + //endregion + }; + + private static final int[] BOX_INDICES = { + //region + // min X, vertical face + 2, 1, 0, + 0, 3, 2, + // max X, vertical face + 6, 5, 4, + 4, 7, 6, + + // min Z, vertical face + 10, 9, 8, + 8, 11, 10, + // max Z, vertical face + 14, 13, 12, + 12, 15, 14, + + // min Y, horizontal face + 18, 17, 16, + 16, 19, 18, + // max Y, horizontal face + 20, 21, 22, + 22, 23, 20, + //endregion + }; + + private final ConcurrentHashMap boxGroupById = new ConcurrentHashMap<>(); + + + // rendering setup + private boolean init = false; + + private VertexFormat vertexFormat; + + private RenderPipeline opaquePipeline; + private RenderPipeline transparentPipeline; + + private GpuBuffer boxVertexBuffer; + private GpuBuffer boxIndexBuffer; + + private GpuBuffer fragUniformBuffer; + private GpuBuffer vertUniformBuffer; + + + + //=============// + // constructor // + //=============// + //region + + public McGenericObjectRenderer_Textures() { } + + public void init() + { + if (this.init) + { + return; + } + this.init = true; + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) + .build(); + + this.createPipelines(); + this.createBuffers(); + + if (RENDER_DEBUG_OBJECTS) + { + this.addGenericDebugObjects(); + } + } + private void createPipelines() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(true); + pipelineBuilder.withDepthWrite(true); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:generic")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/frag")); + + pipelineBuilder.withSampler("uColorMap"); + + pipelineBuilder.withSampler("uLightMap"); + + pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + } + + // opaque + { + pipelineBuilder.withoutBlend(); + this.opaquePipeline = pipelineBuilder.build(); + } + + // transparent + { + pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); + this.transparentPipeline = pipelineBuilder.build(); + } + + } + private void createBuffers() + { + // box vertices + ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); + boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); + boxVerticesBuffer.rewind(); + MemoryUtil.memFree(boxVerticesBuffer); + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // upload vertex data + { + Supplier labelSupplier = () -> "distantHorizons:McGenericRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = BOX_VERTICES.length * Float.BYTES; + this.boxVertexBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = BOX_VERTICES.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxVertexBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(BOX_VERTICES); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + // box vertex indexes + { + ByteBuffer buffer = ByteBuffer.allocateDirect(BOX_INDICES.length * Integer.BYTES); + buffer.asIntBuffer().put(BOX_INDICES); + buffer.rewind(); + + + // TODO + // GpuBuffer.USAGE_UNIFORM = 128 + // GpuBuffer.USAGE_INDEX = 64 + int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + this.boxIndexBuffer = gpuDevice.createBuffer(() -> "DH Generic Index Buffer", usage, buffer.capacity()); + + int offset = 0; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxIndexBuffer, offset, buffer.capacity()); + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + } + private void addGenericDebugObjects() + { + GenericRenderObjectFactory factory = GenericRenderObjectFactory.INSTANCE; + + + // single giant box + IDhApiRenderableBoxGroup singleGiantBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":CyanChunkBox", + new DhApiRenderableBox( + new DhApiVec3d(0,0,0), new DhApiVec3d(16,190,16), + new Color(Color.CYAN.getRed(), Color.CYAN.getGreen(), Color.CYAN.getBlue(), 125), + EDhApiBlockMaterial.WATER) + ); + singleGiantBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleGiantBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleGiantBoxGroup); + + + // single slender box + IDhApiRenderableBoxGroup singleTallBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":GreenBeacon", + new DhApiRenderableBox( + new DhApiVec3d(16,0,31), new DhApiVec3d(17,2000,32), + new Color(Color.GREEN.getRed(), Color.GREEN.getGreen(), Color.GREEN.getBlue(), 125), + EDhApiBlockMaterial.ILLUMINATED) + ); + singleTallBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleTallBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleTallBoxGroup); + + + // absolute box group + ArrayList absBoxList = new ArrayList<>(); + for (int i = 0; i < 18; i++) + { + absBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(i,150+i,24), new DhApiVec3d(1+i,151+i,25), + new Color(Color.ORANGE.getRed(), Color.ORANGE.getGreen(), Color.ORANGE.getBlue()), + EDhApiBlockMaterial.LAVA + ) + ); + } + IDhApiRenderableBoxGroup absolutePosBoxGroup = factory.createAbsolutePositionedGroup(ModInfo.NAME + ":OrangeStairs", absBoxList); + this.add(absolutePosBoxGroup); + + + // relative box group + ArrayList relBoxList = new ArrayList<>(); + for (int i = 0; i < 8; i+=2) + { + relBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(0,i,0), new DhApiVec3d(1,1+i,1), + new Color(Color.MAGENTA.getRed(), Color.MAGENTA.getGreen(), Color.MAGENTA.getBlue()), + EDhApiBlockMaterial.METAL + ) + ); + } + IDhApiRenderableBoxGroup relativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MovingMagentaGroup", + new DhApiVec3d(24, 140, 24), + relBoxList); + relativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d pos = relativePosBoxGroup.getOriginBlockPos(); + pos.x += event.partialTicks / 2; + pos.x %= 32; + relativePosBoxGroup.setOriginBlockPos(pos); + }); + this.add(relativePosBoxGroup); + + + // massive relative box group + ArrayList massRelBoxList = new ArrayList<>(); + for (int x = 0; x < 50*2; x+=2) + { + for (int z = 0; z < 50*2; z+=2) + { + massRelBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(-x, 0, -z), new DhApiVec3d(1-x, 1, 1-z), + new Color(Color.RED.getRed(), Color.RED.getGreen(), Color.RED.getBlue()), + EDhApiBlockMaterial.TERRACOTTA + ) + ); + } + } + IDhApiRenderableBoxGroup massRelativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MassRedGroup", + new DhApiVec3d(-25, 140, 0), + massRelBoxList); + massRelativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d blockPos = massRelativePosBoxGroup.getOriginBlockPos(); + blockPos.y += event.partialTicks / 4; + if (blockPos.y > 150f) + { + blockPos.y = 140f; + + Color newColor = (massRelativePosBoxGroup.get(0).color == Color.RED) ? Color.RED.darker() : Color.RED; + massRelativePosBoxGroup.forEach((box) -> { box.color = newColor; }); + massRelativePosBoxGroup.triggerBoxChange(); + } + + massRelativePosBoxGroup.setOriginBlockPos(blockPos); + }); + this.add(massRelativePosBoxGroup); + } + + //endregion + + + + //==============// + // registration // + //==============// + //region + + @Override + public void add(IDhApiRenderableBoxGroup iBoxGroup) throws IllegalArgumentException + { + if (!(iBoxGroup instanceof RenderableBoxGroup)) + { + throw new IllegalArgumentException("Box group must be of type ["+ RenderableBoxGroup.class.getSimpleName()+"], type received: ["+(iBoxGroup != null ? iBoxGroup.getClass() : "NULL")+"]."); + } + RenderableBoxGroup boxGroup = (RenderableBoxGroup) iBoxGroup; + + + long id = boxGroup.getId(); + if (this.boxGroupById.containsKey(id)) + { + throw new IllegalArgumentException("A box group with the ID [" + id + "] is already present."); + } + + this.boxGroupById.put(id, boxGroup); + } + + @Override + public IDhApiRenderableBoxGroup remove(long id) { return this.boxGroupById.remove(id); } + + public void clear() { this.boxGroupById.clear(); } + + //endregion + + + + //===========// + // rendering // + //===========// + //region + + /** + * @param renderingWithSsao + * if true that means this render call is happening before the SSAO pass + * and any objects rendered in this pass will have SSAO applied to them. + */ + @Override + public void render(RenderParams renderEventParam, IProfilerWrapper profiler, boolean renderingWithSsao) + { + //==============// + // render setup // + //==============// + //#region + + profiler.push("setup"); + + this.init(); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderSetupEvent.class, renderEventParam); + + Vec3d camPos = MC_RENDER.getCameraExactPosition(); + + //#endregion + + if (McLodRenderer.INSTANCE.dhColorTexture == null + || McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + + + //===========// + // rendering // + //===========// + //#region + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + Collection boxList = this.boxGroupById.values(); + for (RenderableBoxGroup boxGroup : boxList) + { + // validation // + + // shouldn't happen, but just in case + if (boxGroup == null) + { + continue; + } + + // skip boxes that shouldn't render this pass + if (boxGroup.ssaoEnabled != renderingWithSsao) + { + continue; + } + + profiler.popPush("render prep"); + boxGroup.preRender(renderEventParam); // called even if the group is inactive, so the group can be activate if desired + + // ignore inactive groups + if (!boxGroup.active) + { + continue; + } + + // allow API users to cancel this object's rendering + boolean cancelRendering = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericObjectRenderEvent.class, new DhApiBeforeGenericObjectRenderEvent.EventParam(renderEventParam, boxGroup)); + if (cancelRendering) + { + continue; + } + + // update instanced data if needed + { + boxGroup.tryUpdateInstancedDataAsync(); + + // skip groups that haven't been uploaded yet + if (boxGroup.instancedVbos.getState() != InstancedVboContainer.EState.RENDER) + { + continue; + } + } + + + DhApiRenderableBoxGroupShading shading = boxGroup.shading; + if (shading == null) + { + shading = DEFAULT_SHADING; + } + + // uniforms + { + int uniformBufferSize = new Std140SizeCalculator() + .putIVec3() // uOffsetChunk + .putVec3() // uOffsetSubChunk + .putIVec3() // uCameraPosChunk + .putVec3() // uCameraPosSubChunk + + .putMat4f() // uProjectionMvm + .putInt() // uSkyLight + .putInt() // uBlockLight + + .putFloat() // uNorthShading + .putFloat() // uSouthShading + .putFloat() // uEastShading + .putFloat() // uWestShading + .putFloat() // uTopShading + .putFloat() // uBottomShading + .get(); + + + // create data // + + Mat4f projectionMvmMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); + projectionMvmMatrix.multiply(renderEventParam.dhModelViewMatrix); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putIVec3( + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + ) // uOffsetChunk + .putVec3( + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + ) // uOffsetSubChunk + .putIVec3( + LodUtil.getChunkPosFromDouble(camPos.x), + LodUtil.getChunkPosFromDouble(camPos.y), + LodUtil.getChunkPosFromDouble(camPos.z) + ) // uCameraPosChunk + .putVec3( + LodUtil.getSubChunkPosFromDouble(camPos.x), + LodUtil.getSubChunkPosFromDouble(camPos.y), + LodUtil.getSubChunkPosFromDouble(camPos.z) + ) // uCameraPosSubChunk + + .putMat4f(projectionMvmMatrix.createJomlMatrix()) // uProjectionMvm + .putInt(boxGroup.getSkyLight()) // uSkyLight + .putInt(boxGroup.getBlockLight()) // uBlockLight + + .putFloat(shading.north) + .putFloat(shading.south) + .putFloat(shading.east) + .putFloat(shading.west) + .putFloat(shading.top) + .putFloat(shading.bottom) + + .get() + ; + + this.fragUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + + + // render // + + profiler.popPush("rendering"); + profiler.push(boxGroup.getResourceLocationNamespace()); + profiler.push(boxGroup.getResourceLocationPath()); + + Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); + } + + profiler.pop(); // resource path + profiler.pop(); // resource namespace + + boxGroup.postRender(renderEventParam); + } + + //#endregion + + + + //==========// + // clean up // + //==========// + //region + + profiler.popPush("cleanup"); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderCleanupEvent.class, renderEventParam); + + profiler.pop(); + + //endregion + } + + //endregion + + + + //=====================// + // instanced rendering // + //=====================// + //region + + private void renderBoxGroupInstanced( + RenderPass renderPass, RenderParams renderEventParam, + RenderableBoxGroup boxGroup, Vec3d camPos, + IProfilerWrapper profiler) + { + // update instance data // + + profiler.push("vertex setup"); + + GpuDevice gpuDevice = RenderSystem.getDevice(); + + McInstancedVboContainer_Textures container = (McInstancedVboContainer_Textures) boxGroup.instancedVbos; + + + // bind MC Lightmap + { + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + + GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uLightMap", textureView, gpuSampler); + } + + renderPass.setIndexBuffer(this.boxIndexBuffer, VertexFormat.IndexType.INT); + + + + // Bind instance data // + profiler.popPush("binding"); + { + GpuTextureView colorView = gpuDevice.createTextureView(container.colorTexture); + GpuSampler colorSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uColorMap", colorView, colorSampler); + + + renderPass.setVertexBuffer(0, this.boxVertexBuffer); + } + + renderPass.setUniform("vertUniformBlock", this.fragUniformBuffer); + + // set pipeline + renderPass.setPipeline(this.opaquePipeline); // TODO + + // Draw instanced + profiler.popPush("render"); + if (container.uploadedBoxCount > 0) + { + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/BOX_INDICES.length, + /*instanceCount*/container.uploadedBoxCount); + + } + + profiler.pop(); + } + + //endregion + + + + //=========// + // F3 menu // + //=========// + //region + + public String getVboRenderDebugMenuString() + { + // get counts + int totalGroupCount = this.boxGroupById.size(); + int totalBoxCount = 0; + + int activeGroupCount = 0; + int activeBoxCount = 0; + + for (long key : this.boxGroupById.keySet()) + { + RenderableBoxGroup renderGroup = this.boxGroupById.get(key); + if (renderGroup.active) + { + activeGroupCount++; + activeBoxCount += renderGroup.size(); + } + totalBoxCount += renderGroup.size(); + } + + + return "Generic Obj #: " + F3Screen.NUMBER_FORMAT.format(activeGroupCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalGroupCount) + ", " + + "Cube #: " + F3Screen.NUMBER_FORMAT.format(activeBoxCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalBoxCount); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java new file mode 100644 index 000000000..dabe0f385 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java @@ -0,0 +1,392 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.glObject.GLEnums; +import com.seibel.distanthorizons.core.render.glObject.GLProxy; +import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.util.ColorUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; +import org.lwjgl.system.MemoryUtil; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.List; +import java.util.function.Supplier; + +/** + * For use by {@link RenderableBoxGroup} + * + * @see RenderableBoxGroup + */ +public class McInstancedVboContainer implements IInstancedVboContainer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + /** A box from 0,0,0 to 1,1,1 */ + private static final float[] BOX_VERTICES = { + //region + // Pos x y z + + // min X, vertical face + 0, 0, 0, + 1, 0, 0, + 1, 1, 0, + 0, 1, 0, + // max X, vertical face + 0, 1, 1, + 1, 1, 1, + 1, 0, 1, + 0, 0, 1, + + // min Z, vertical face + 0, 0, 1, + 0, 0, 0, + 0, 1, 0, + 0, 1, 1, + // max Z, vertical face + 1, 0, 1, + 1, 1, 1, + 1, 1, 0, + 1, 0, 0, + + // min Y, horizontal face + 0, 0, 1, + 1, 0, 1, + 1, 0, 0, + 0, 0, 0, + // max Y, horizontal face + 0, 1, 1, + 1, 1, 1, + 1, 1, 0, + 0, 1, 0, + //endregion + }; + + private static final int[] BOX_INDICES = { + //region + // min X, vertical face + 2, 1, 0, + 0, 3, 2, + // max X, vertical face + 6, 5, 4, + 4, 7, 6, + + // min Z, vertical face + 10, 9, 8, + 8, 11, 10, + // max Z, vertical face + 14, 13, 12, + 12, 15, 14, + + // min Y, horizontal face + 18, 17, 16, + 16, 19, 18, + // max Y, horizontal face + 20, 21, 22, + 22, 23, 20, + //endregion + }; + + public static final int[][][] DIRECTION_VERTEX_IBO_QUAD = new int[][][] + ///region + { + // X,Z // + { // UP + {1, 0}, // 0 + {1, 1}, // 1 + {0, 1}, // 2 + {0, 0}, // 3 + }, + { // DOWN + {0, 0}, // 0 + {0, 1}, // 1 + {1, 1}, // 2 + {1, 0}, // 3 + }, + + // X,Y // + { // NORTH + {0, 0}, // 0 + {0, 1}, // 1 + {1, 1}, // 2 + + {1, 0}, // 3 + }, + { // SOUTH + {1, 0}, // 0 + {1, 1}, // 1 + {0, 1}, // 2 + + {0, 0}, // 3 + }, + + // Z,Y // + { // WEST + {0, 0}, // 0 + {1, 0}, // 1 + {1, 1}, // 2 + + {0, 1}, // 3 + }, + { // EAST + {0, 1}, // 0 + {1, 1}, // 1 + {1, 0}, // 2 + + {0, 0}, // 3 + }, + }; + ///endregion + + + + + + public GpuBuffer vboGpuBuffer; + public GpuBuffer indexGpuBuffer; + + //public int[] chunkPosData = new int[0]; + //public float[] subChunkPosData = new float[0]; + ////public float[] scalingData = new float[0]; + //public float[] colorData = new float[0]; + //public int[] materialData = new int[0]; + private ByteBuffer vertexBuffer = ByteBuffer.allocateDirect(0); + private ByteBuffer indexBuffer = ByteBuffer.allocateDirect(0); + + public int uploadedBoxCount = 0; + + private EState state = EState.NEW; + @Override + public IInstancedVboContainer.EState getState() { return this.state; } + @Override + public void setState(IInstancedVboContainer.EState state) { this.state = state; } + + + + //===========================// + // render building/uploading // + //===========================// + //region + + public void updateVertexData(List uploadBoxList) + { + int boxCount = uploadBoxList.size(); + if (boxCount == 0) + { + return; // TODO done just to fix a buffer empty crash + } + + + // recreate the data arrays if their size is different + if (this.uploadedBoxCount != boxCount) + { + this.uploadedBoxCount = boxCount; + + int vertexBufferSize = this.vertexBufferSize(); + this.vertexBuffer = ByteBuffer.allocateDirect(vertexBufferSize); + this.vertexBuffer.order(ByteOrder.LITTLE_ENDIAN); + + int indexBufferSize = this.indexBufferSize(); + this.indexBuffer = ByteBuffer.allocateDirect(indexBufferSize); + this.indexBuffer.order(ByteOrder.LITTLE_ENDIAN); + } + this.vertexBuffer.position(0); + this.indexBuffer.position(0); + + + + //QuadElementBuffer.buildBuffer(quadCount, this.indexBuffer, GL32.GL_UNSIGNED_INT); + + + + for (int boxIndex = 0; boxIndex < boxCount; boxIndex++) + { + // index + int indexOffset = (boxIndex * 24 /*24 is the number of vertices in a box*/); + for (int i = 0; i < BOX_INDICES.length; i++) + { + this.indexBuffer.putInt(BOX_INDICES[i] + indexOffset); + } + + + + + // vertex + DhApiRenderableBox box = uploadBoxList.get(boxIndex); + + final double[] boxVertices = { + //region + // Pos x y z + + // min X, vertical face + box.minPos.x, box.minPos.y, box.minPos.z, + box.maxPos.x, box.minPos.y, box.minPos.z, + box.maxPos.x, box.maxPos.y, box.minPos.z, + box.minPos.x, box.maxPos.y, box.minPos.z, + // max X, vertical face + box.minPos.x, box.maxPos.y, box.maxPos.z, + box.maxPos.x, box.maxPos.y, box.maxPos.z, + box.maxPos.x, box.minPos.y, box.maxPos.z, + box.minPos.x, box.minPos.y, box.maxPos.z, + + // min Z, vertical face + box.minPos.x, box.minPos.y, box.maxPos.z, + box.minPos.x, box.minPos.y, box.minPos.z, + box.minPos.x, box.maxPos.y, box.minPos.z, + box.minPos.x, box.maxPos.y, box.maxPos.z, + // max Z, vertical face + box.maxPos.x, box.minPos.y, box.maxPos.z, + box.maxPos.x, box.maxPos.y, box.maxPos.z, + box.maxPos.x, box.maxPos.y, box.minPos.z, + box.maxPos.x, box.minPos.y, box.minPos.z, + + // min Y, horizontal face + box.minPos.x, box.minPos.y, box.maxPos.z, + box.maxPos.x, box.minPos.y, box.maxPos.z, + box.maxPos.x, box.minPos.y, box.minPos.z, + box.minPos.x, box.minPos.y, box.minPos.z, + // max Y, horizontal face + box.minPos.x, box.maxPos.y, box.maxPos.z, + box.maxPos.x, box.maxPos.y, box.maxPos.z, + box.maxPos.x, box.maxPos.y, box.minPos.z, + box.minPos.x, box.maxPos.y, box.minPos.z, + //endregion + }; + + for (int vertexIndex = 0; vertexIndex < boxVertices.length; vertexIndex+=3) + { + this.vertexBuffer.putFloat((float)boxVertices[vertexIndex]); // x + this.vertexBuffer.putFloat((float)boxVertices[vertexIndex+1]); // y + this.vertexBuffer.putFloat((float)boxVertices[vertexIndex+2]); // z + + int color = ColorUtil.toColorInt(box.color); + byte r = (byte) ColorUtil.getRed(color); + byte g = (byte) ColorUtil.getGreen(color); + byte b = (byte) ColorUtil.getBlue(color); + byte a = (byte) ColorUtil.getAlpha(color); + this.vertexBuffer.put(r); + this.vertexBuffer.put(g); + this.vertexBuffer.put(b); + this.vertexBuffer.put(a); + + this.vertexBuffer.put(box.material); + // TODO make sure this all is a multiple of 4 like LodQuadBuilder (might cause issues with AMD/Mac otherwise) + } + } + this.vertexBuffer.flip(); + this.indexBuffer.flip(); + + + this.state = McInstancedVboContainer.EState.READY_TO_UPLOAD; + } + + private int vertexBufferSize() + { + int faceCount = this.uploadedBoxCount * 6; + int vertexCount = faceCount * 6; + + int byteSize = vertexCount * 3 * Float.BYTES; // x,y,z + byteSize += vertexCount * 4; // r,g,b,a + byteSize += 1; // material + return byteSize; + } + private int indexBufferSize() + { + int quadCount = this.uploadedBoxCount * 36; + int byteSize = quadCount * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6; + return byteSize; + + //int faceCount = this.uploadedBoxCount * 6; + //int vertexCount = faceCount * 6; + //int byteSize = vertexCount * Integer.BYTES; + //return byteSize; + } + + public void uploadDataToGpu() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // vertex + { + int totalVertexByteSize = this.vertexBufferSize(); + if (this.vboGpuBuffer == null + || this.vboGpuBuffer.size() < totalVertexByteSize) + { + Supplier labelSupplier = () -> "distantHorizons:GenericContainerVertex"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, totalVertexByteSize); + } + + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, totalVertexByteSize); + commandEncoder.writeToBuffer(bufferSlice, this.vertexBuffer); + } + + // index + { + int totalVertexByteSize = this.indexBufferSize(); + if (this.indexGpuBuffer == null + || this.indexGpuBuffer.size() < totalVertexByteSize) + { + Supplier labelSupplier = () -> "distantHorizons:GenericContainerIndex"; + // GpuBuffer.USAGE_UNIFORM = 128 + // GpuBuffer.USAGE_INDEX = 64 + int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + this.indexGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, totalVertexByteSize); + } + + int offset = 0; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexGpuBuffer, offset, totalVertexByteSize); + + commandEncoder.writeToBuffer(bufferSlice, this.indexBuffer); + } + + this.state = EState.RENDER; + } + + //endregion + + + + //================// + // base overrides // + //================// + //region + + @Override + public void close() + { + GLProxy.queueRunningOnRenderThread(() -> + { + if (this.vboGpuBuffer != null) + { + this.vboGpuBuffer.close(); + } + if (this.indexGpuBuffer != null) + { + this.indexGpuBuffer.close(); + } + }); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java new file mode 100644 index 000000000..a71d47641 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java @@ -0,0 +1,277 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.platform.NativeImage; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.GpuTexture; +import com.mojang.blaze3d.textures.TextureFormat; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.glObject.GLProxy; +import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; + +import java.awt.*; +import java.nio.ByteBuffer; +import java.util.List; + + +/** + * For use by {@link RenderableBoxGroup} + * + * @see RenderableBoxGroup + */ +public class McInstancedVboContainer_Textures implements IInstancedVboContainer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + + + public GpuTexture colorTexture; + public GpuTexture scaleTexture; + public GpuTexture chunkPosXTexture; + public GpuTexture chunkPosYTexture; + public GpuTexture chunkPosZTexture; + public GpuTexture subChunkPosTexture; + public GpuTexture materialTexture; + + public int[] chunkPosData = new int[0]; + public float[] subChunkPosData = new float[0]; + public float[] scaleData = new float[0]; + public byte[] colorData = new byte[0]; + public int[] materialData = new int[0]; + + public int uploadedBoxCount = 0; + + private EState state = EState.NEW; + @Override + public EState getState() { return this.state; } + @Override + public void setState(EState state) { this.state = state; } + + + + //===========================// + // render building/uploading // + //===========================// + //region + + public void updateVertexData(List uploadBoxList) + { + int boxCount = uploadBoxList.size(); + + + // recreate the data arrays if their size is different + if (this.uploadedBoxCount != boxCount) + { + this.uploadedBoxCount = boxCount; + + this.chunkPosData = new int[boxCount * 3]; // 3 elements XYZ + this.subChunkPosData = new float[boxCount * 3]; // 3 elements XYZ + this.scaleData = new float[boxCount * 3]; // 3 elements XYZ + + this.colorData = new byte[boxCount * 4]; // 4 elements, RGBA + this.materialData = new int[boxCount]; + } + + + // transformation / scaling // + for (int i = 0; i < boxCount; i++) + { + DhApiRenderableBox box = uploadBoxList.get(i); + + int dataIndex = i * 3; + + this.chunkPosData[dataIndex] = LodUtil.getChunkPosFromDouble(box.minPos.x); + this.chunkPosData[dataIndex + 1] = LodUtil.getChunkPosFromDouble(box.minPos.y); + this.chunkPosData[dataIndex + 2] = LodUtil.getChunkPosFromDouble(box.minPos.z); + + this.subChunkPosData[dataIndex] = LodUtil.getSubChunkPosFromDouble(box.minPos.x); + this.subChunkPosData[dataIndex + 1] = LodUtil.getSubChunkPosFromDouble(box.minPos.y); + this.subChunkPosData[dataIndex + 2] = LodUtil.getSubChunkPosFromDouble(box.minPos.z); + + this.scaleData[dataIndex] = (float) (box.maxPos.x - box.minPos.x); + this.scaleData[dataIndex + 1] = (float) (box.maxPos.y - box.minPos.y); + this.scaleData[dataIndex + 2] = (float) (box.maxPos.z - box.minPos.z); + } + + + // colors/materials // + for (int i = 0; i < boxCount; i++) + { + DhApiRenderableBox box = uploadBoxList.get(i); + Color color = box.color; + int colorIndex = i * 4; + this.colorData[colorIndex] = (byte)color.getRed(); + this.colorData[colorIndex + 1] = (byte)color.getGreen(); + this.colorData[colorIndex + 2] = (byte)color.getBlue(); + this.colorData[colorIndex + 3] = (byte)color.getAlpha(); + + this.materialData[i] = box.material; + } + + this.state = EState.READY_TO_UPLOAD; + } + + public void uploadDataToGpu() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + if (this.colorTexture == null + || this.colorTexture.getWidth(0) < this.uploadedBoxCount) + { + // TODO USAGE_COPY_DST = 1 + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 1 | 4 | 8 | 32 | 128; + String texturePrefix = "DhGenericTexture_"; + + this.colorTexture = gpuDevice.createTexture(texturePrefix + "Color", + usage, + TextureFormat.RGBA8, + this.uploadedBoxCount, 1, + 1, 1 + ); + + this.scaleTexture = gpuDevice.createTexture(texturePrefix + "Scale", + usage, + TextureFormat.RGBA8, + this.uploadedBoxCount, 1, + 1, 1 + ); + + this.chunkPosXTexture = gpuDevice.createTexture(texturePrefix + "ChunkXPos", + usage, + TextureFormat.DEPTH32, + this.uploadedBoxCount, 1, + 1, 1 + ); + this.chunkPosYTexture = gpuDevice.createTexture(texturePrefix + "ChunkYPos", + usage, + TextureFormat.DEPTH32, + this.uploadedBoxCount, 1, + 1, 1 + ); + this.chunkPosZTexture = gpuDevice.createTexture(texturePrefix + "ChunkZPos", + usage, + TextureFormat.DEPTH32, + this.uploadedBoxCount, 1, + 1, 1 + ); + + this.subChunkPosTexture = gpuDevice.createTexture(texturePrefix + "SubChunk", + usage, + TextureFormat.RGBA8, + this.uploadedBoxCount, 1, + 1, 1 + ); + + //this.materialTexture = gpuDevice.createTexture(texturePrefix + "Material", + // usage, + // TextureFormat.RED8I, // TODO not valid? + // this.uploadedBoxCount, 1, + // 1, 1 + //); + } + + { + // color + { + ByteBuffer colorBuffer = ByteBuffer.allocateDirect(this.colorData.length * Float.BYTES); + colorBuffer.asFloatBuffer(); + + for (int i = 0; i < this.colorData.length; i++) + { + colorBuffer.put(this.colorData[i]); + } + colorBuffer.rewind(); + + commandEncoder.writeToTexture( + this.colorTexture, + colorBuffer, + NativeImage.Format.RGBA, // holds bytes + 0, //mipLevel + 0, // depthOrLayer + 0, // destX + 0, // destY + this.uploadedBoxCount, // width + 1 // height + ); + } + + // scale + { + ByteBuffer scaleBuffer = ByteBuffer.allocateDirect(this.scaleData.length * Float.BYTES); + scaleBuffer.asFloatBuffer(); + + for (int i = 0; i < this.scaleData.length; i++) + { scaleBuffer.putFloat(this.scaleData[i]); } + scaleBuffer.rewind(); + + commandEncoder.writeToTexture( + this.scaleTexture, + scaleBuffer, + NativeImage.Format.RGB, // holds bytes + 0, //mipLevel + 0, // depthOrLayer + 0, // destX + 0, // destY + this.uploadedBoxCount, // width + 1 // height + ); + } + + + //for (int i = 0; i < this.chunkPosData.length; i++) + //{ buffer.putInt(this.chunkPosData[i]); } + // + //for (int i = 0; i < this.subChunkPosData.length; i++) + //{ buffer.putFloat(this.subChunkPosData[i]); } + // + //for (int i = 0; i < this.colorData.length; i++) + //{ buffer.putFloat(this.colorData[i]); } + // + //for (int i = 0; i < this.materialData.length; i++) + //{ buffer.putInt(this.materialData[i]); } + // + //buffer.rewind(); + } + + this.state = EState.RENDER; + } + + //endregion + + + + //================// + // base overrides // + //================// + //region + + @Override + public void close() + { + GLProxy.queueRunningOnRenderThread(() -> + { + if (this.colorTexture != null) + { + this.colorTexture.close(); + } + }); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java index ab6d739f4..295f1e719 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java @@ -195,48 +195,11 @@ public class McTestRenderer implements IMcTestRenderer // render pass setup { - // set uniform - if (false) - { - Supplier labelSupplier = () -> ""; - int usage = 0; - int size = 0; - GpuBuffer gpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - renderPass.setUniform("name", gpuBuffer); - } - - // bind depth texture - if (false) - { - GpuTexture bindDepthTexture = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); - - GpuTextureView textureView = gpuDevice.createTextureView(bindDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 0, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("depth", textureView, gpuSampler); - } - - // index buffer - if (false) - { - GpuBuffer buffer = null; - renderPass.setIndexBuffer(buffer, VertexFormat.IndexType.INT); - } - // bind VBO - { - renderPass.setVertexBuffer(0, vboGpuBuffer); // vertex buffer can only be "0" lol - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol // set pipeline - { - renderPass.setPipeline(this.pipeline); - } + renderPass.setPipeline(this.pipeline); } // draw render pass diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 6b10976d2..9ec50b096 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,6 +24,8 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; +import com.seibel.distanthorizons.common.renderTest.McGenericObjectRenderer; +import com.seibel.distanthorizons.common.renderTest.McInstancedVboContainer; import com.seibel.distanthorizons.common.renderTest.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; @@ -33,10 +35,12 @@ import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; +import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; @@ -358,9 +362,24 @@ public class WrapperFactory implements IWrapperFactory } + @Override public IVertexBufferWrapper createVboWrapper() { return new VertexBufferWrapper(); } + @Override + public IInstancedVboContainer createInstancedVboContainer() + { + return new McInstancedVboContainer(); + } + + @Override + public IMcGenericRenderer createGenericRenderer() + { + return new McGenericObjectRenderer(); + } + + + } diff --git a/coreSubProjects b/coreSubProjects index 200e089a3..3d9ae5f08 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 200e089a3336ea61c4012f762c6e19d6c5c6c1bb +Subproject commit 3d9ae5f088d24387152bf336e752d041d5a5fb8d From 2fbeb438943c1136271134f6f1ecf12a450a0d95 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 2 Mar 2026 07:45:30 -0600 Subject: [PATCH 14/72] add SSAO --- .../renderTest/McSsaoApplyRenderer.java | 252 ++++++++++++++ .../common/renderTest/McSsaoRenderer.java | 329 ++++++++++++++++++ .../common/wrappers/DependencySetup.java | 3 + coreSubProjects | 2 +- 4 files changed, 585 insertions(+), 1 deletion(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java new file mode 100644 index 000000000..e6a0f66dd --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java @@ -0,0 +1,252 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.DestFactor; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.platform.SourceFactor; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.AddressMode; +import com.mojang.blaze3d.textures.FilterMode; +import com.mojang.blaze3d.textures.GpuSampler; +import com.mojang.blaze3d.textures.GpuTextureView; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO ??? + */ +public class McSsaoApplyRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McSsaoApplyRenderer INSTANCE = new McSsaoApplyRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer vboGpuBuffer; + + + //=============// + // constructor // + //=============// + //region + + private McSsaoApplyRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withBlend(new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE)); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:ssao_apply_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/apply")); + + pipelineBuilder.withSampler("uSsaoColorTexture"); + pipelineBuilder.withSampler("uDhDepthTexture"); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McApplyRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + if (McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // create a render pass + { + Supplier debugLabelSupplier = () -> "distantHorizons:McApplySsaoRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind SSAO color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McSsaoRenderer.INSTANCE.ssaoColorTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uSsaoColorTexture", textureView, gpuSampler); + } + + // bind DH LOD depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java new file mode 100644 index 000000000..6938d0986 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java @@ -0,0 +1,329 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * Renders a TODO + */ +public class McSsaoRenderer implements IMcSsaoRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McSsaoRenderer INSTANCE = new McSsaoRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer fragUniformBuffer; + + private GpuBuffer vboGpuBuffer; + + public GpuTexture ssaoColorTexture; + + + + //=============// + // constructor // + //=============// + //region + + private McSsaoRenderer() + { + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/ao")); + + pipelineBuilder.withSampler("uMcDepthTexture"); + pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); + + pipelineBuilder.withSampler("uDhDepthTexture"); + + pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + @Override + public void render(DhApiMat4f dhProjectionMatrix) + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhDepthTexture == null + || McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // textures + if (this.ssaoColorTexture == null + || this.ssaoColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.ssaoColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + { + if (this.ssaoColorTexture != null) + { + this.ssaoColorTexture.close(); + } + + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.ssaoColorTexture = gpuDevice.createTexture("SsaoColorTexture", + usage, + TextureFormat.RGBA8, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); + } + + + { + int uniformBufferSize = new Std140SizeCalculator() + .putInt() // uSampleCount\ + + .putFloat() // uRadius + .putFloat() // uStrength + .putFloat() // uMinLight + .putFloat() // uBias + .putFloat() // uFadeDistanceInBlocks + + .putMat4f() // uInvProj + .putMat4f() // uProj + .get(); + + + // create data // + + Mat4f projMatrix = new Mat4f(dhProjectionMatrix); + Mat4f invertedProjMatrix = new Mat4f(dhProjectionMatrix); + invertedProjMatrix.invert(); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putInt(6) // uSampleCount + + .putFloat(4.0f) // uRadius + .putFloat(0.2f) // uStrength + .putFloat(0.25f) // uMinLight + .putFloat(0.02f) // uBias + .putFloat(1_600.0f) // uFadeDistanceInBlocks + + .putMat4f(invertedProjMatrix.createJomlMatrix()) + .putMat4f(projMatrix.createJomlMatrix()) + .get() + ; + + this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + this.renderSsaoToTexture(); + // TODO + McSsaoApplyRenderer.INSTANCE.render(); + + } + + private void renderSsaoToTexture() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McSsaoRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(this.ssaoColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind DH depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 5f38f083f..170874605 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.common.renderTest.McFadeRenderer; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.McSsaoRenderer; import com.seibel.distanthorizons.common.renderTest.McTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; @@ -41,6 +42,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRen import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; /** @@ -81,6 +83,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFadeRenderer.class, McFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); } } diff --git a/coreSubProjects b/coreSubProjects index 3d9ae5f08..84c212a78 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 3d9ae5f088d24387152bf336e752d041d5a5fb8d +Subproject commit 84c212a78040457ca2fb88c998dc95c4758cb1f1 From 71aaff32a2fa4178b8ab73ad58e21f3b831a4320 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 3 Mar 2026 07:48:04 -0600 Subject: [PATCH 15/72] add fog --- .../common/renderTest/McFogApplyRenderer.java | 251 ++++++++++ .../common/renderTest/McFogRenderer.java | 443 ++++++++++++++++++ .../common/renderTest/McSsaoRenderer.java | 1 - .../common/wrappers/DependencySetup.java | 11 +- coreSubProjects | 2 +- 5 files changed, 698 insertions(+), 10 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java new file mode 100644 index 000000000..830c424f9 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java @@ -0,0 +1,251 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.DestFactor; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.platform.SourceFactor; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.AddressMode; +import com.mojang.blaze3d.textures.FilterMode; +import com.mojang.blaze3d.textures.GpuSampler; +import com.mojang.blaze3d.textures.GpuTextureView; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO ??? + */ +public class McFogApplyRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McFogApplyRenderer INSTANCE = new McFogApplyRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer vboGpuBuffer; + + + //=============// + // constructor // + //=============// + //region + + private McFogApplyRenderer() + { + + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withBlend(new BlendFunction(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA)); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:fog_apply_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/quad_apply")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/apply")); + + pipelineBuilder.withSampler("uColorTexture"); + pipelineBuilder.withSampler("uDhDepthTexture"); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McFogApplyRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + if (McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // create a render pass + { + Supplier debugLabelSupplier = () -> "distantHorizons:McApplyFogRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind fog color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McFogRenderer.INSTANCE.fogColorTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uColorTexture", textureView, gpuSampler); + } + + // bind DH LOD depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java new file mode 100644 index 000000000..0aec345a0 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java @@ -0,0 +1,443 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFogRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; +import net.minecraft.resources.Identifier; + +import java.awt.*; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * Renders a TODO + */ +public class McFogRenderer implements IMcFogRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McFogRenderer INSTANCE = new McFogRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer fragUniformBuffer; + + private GpuBuffer vboGpuBuffer; + + public GpuTexture fogColorTexture; + + + + //=============// + // constructor // + //=============// + //region + + private McFogRenderer() + { + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:fog_render")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/quad_apply")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/fog")); + + pipelineBuilder.withSampler("uMcDepthTexture"); + pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); + + pipelineBuilder.withSampler("uDhDepthTexture"); + + pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McFogRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + @Override + public void render(DhApiMat4f modelViewProjectionMatrix, float partialTicks) + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhDepthTexture == null + || McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // textures + if (this.fogColorTexture == null + || this.fogColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.fogColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + { + if (this.fogColorTexture != null) + { + this.fogColorTexture.close(); + } + + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.fogColorTexture = gpuDevice.createTexture("FogColorTexture", + usage, + TextureFormat.RGBA8, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); + } + + + { + int uniformBufferSize = new Std140SizeCalculator() + + // fog uniforms + .putVec4() // uFogColor + .putFloat() //uFogScale + .putFloat() //uFogVerticalScale + // only used for debugging + .putInt() //uFogDebugMode // 1 = render everything with fog color // 7 = use debug rendering + .putInt() //uFogFalloffType + + // fog config + .putFloat() // uFarFogStart + .putFloat() // uFarFogLength + .putFloat() // uFarFogMin + .putFloat() // uFarFogRange + .putFloat() // uFarFogDensity + + // height fog config + .putFloat() // uHeightFogStart + .putFloat() // uHeightFogLength + .putFloat() // uHeightFogMin + .putFloat() // uHeightFogRange + .putFloat() // uHeightFogDensity + + // ?? + .putInt() // uHeightFogEnabled + .putInt() // uHeightFogFalloffType + .putInt() // uHeightBasedOnCamera + .putFloat() // uHeightFogBaseHeight + .putInt() // uHeightFogAppliesUp + .putInt() // uHeightFogAppliesDown + .putInt() // uUseSphericalFog + .putInt() // uHeightFogMixingMode + .putFloat() // uCameraBlockYPos + + .putMat4f() // uInvMvmProj + + .get(); + + + // create data // + + + int lodDrawDistance = Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius.get() * LodUtil.CHUNK_WIDTH; + + + Mat4f inverseMvmProjMatrix = new Mat4f(modelViewProjectionMatrix); + inverseMvmProjMatrix.invert(); + + if (modelViewProjectionMatrix == null) + { + return; + } + + + Color fogColor = this.getFogColor(partialTicks); + + // fog config + float farFogStart = Config.Client.Advanced.Graphics.Fog.farFogStart.get(); + float farFogEnd = Config.Client.Advanced.Graphics.Fog.farFogEnd.get(); + float farFogMin = Config.Client.Advanced.Graphics.Fog.farFogMin.get(); + float farFogMax = Config.Client.Advanced.Graphics.Fog.farFogMax.get(); + float farFogDensity = Config.Client.Advanced.Graphics.Fog.farFogDensity.get(); + + // override fog if underwater + if (MC_RENDER.isFogStateSpecial()) + { + // hide everything behind fog + farFogStart = 0.0f; + farFogEnd = 0.0f; + } + + + // height config + EDhApiHeightFogMixMode heightFogMixingMode = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMixMode.get(); + boolean heightFogEnabled = heightFogMixingMode != EDhApiHeightFogMixMode.SPHERICAL && heightFogMixingMode != EDhApiHeightFogMixMode.CYLINDRICAL; + boolean useSphericalFog = heightFogMixingMode == EDhApiHeightFogMixMode.SPHERICAL; + EDhApiHeightFogDirection heightFogCameraDirection = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogDirection.get(); + + float heightFogStart = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogStart.get(); + float heightFogEnd = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogEnd.get(); + float heightFogMin = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMin.get(); + float heightFogMax = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMax.get(); + float heightFogDensity = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogDensity.get(); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + + // fog uniforms + .putVec4( + fogColor.getRed() / 255.0f, + fogColor.getGreen() / 255.0f, + fogColor.getBlue() / 255.0f, + fogColor.getAlpha() / 255.0f) // uFogColor + .putFloat(1.f / lodDrawDistance) //uFogScale + .putFloat(1.f / MC.getWrappedClientLevel().getMaxHeight()) //uFogVerticalScale + // only used for debugging + .putInt(0) //uFogDebugMode // 1 = render everything with fog color // 7 = use debug rendering + .putInt(Config.Client.Advanced.Graphics.Fog.farFogFalloff.get().value) //uFogFalloffType + + // fog config + .putFloat(farFogStart) // uFarFogStart + .putFloat(farFogEnd - farFogStart) // uFarFogLength + .putFloat(farFogMin) // uFarFogMin + .putFloat(farFogMax - farFogMin) // uFarFogRange + .putFloat(farFogDensity) // uFarFogDensity + + // height fog config + .putFloat(heightFogStart) // uHeightFogStart + .putFloat(heightFogEnd - heightFogStart) // uHeightFogLength + .putFloat(heightFogMin) // uHeightFogMin + .putFloat(heightFogMax - heightFogMin) // uHeightFogRange + .putFloat(heightFogDensity) // uHeightFogDensity + + // ?? + .putInt(heightFogEnabled ? 1 : 0) // uHeightFogEnabled + .putInt(Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogFalloff.get().value) // uHeightFogFalloffType + .putInt(heightFogCameraDirection.basedOnCamera ? 1 : 0) // uHeightBasedOnCamera + .putFloat(Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogBaseHeight.get()) // uHeightFogBaseHeight + .putInt(heightFogCameraDirection.fogAppliesUp ? 1 : 0) // uHeightFogAppliesUp + .putInt(heightFogCameraDirection.fogAppliesDown ? 1 : 0) // uHeightFogAppliesDown + .putInt(useSphericalFog ? 1 : 0) // uUseSphericalFog + .putInt(heightFogMixingMode.value) // uHeightFogMixingMode + .putFloat((float)MC_RENDER.getCameraExactPosition().y) // uCameraBlockYPos + + .putMat4f(inverseMvmProjMatrix.createJomlMatrix()) // uInvMvmProj + + .get() + ; + + this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + this.renderFogToTexture(); + McFogApplyRenderer.INSTANCE.render(); + + } + + private Color getFogColor(float partialTicks) + { + Color fogColor; + + if (Config.Client.Advanced.Graphics.Fog.colorMode.get() == EDhApiFogColorMode.USE_SKY_COLOR) + { + fogColor = MC_RENDER.getSkyColor(); + } + else + { + fogColor = MC_RENDER.getFogColor(partialTicks); + } + + return fogColor; + } + + private void renderFogToTexture() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McFogRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(this.fogColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind DH depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java index 6938d0986..0d2f0ceda 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java @@ -261,7 +261,6 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.renderSsaoToTexture(); - // TODO McSsaoApplyRenderer.INSTANCE.render(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 170874605..6db5157f0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,10 +19,7 @@ package com.seibel.distanthorizons.common.wrappers; -import com.seibel.distanthorizons.common.renderTest.McFadeRenderer; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.McSsaoRenderer; -import com.seibel.distanthorizons.common.renderTest.McTestRenderer; +import com.seibel.distanthorizons.common.renderTest.*; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; @@ -40,10 +37,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.*; /** * Binds all necessary dependencies, so we @@ -84,6 +78,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcFadeRenderer.class, McFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); } } diff --git a/coreSubProjects b/coreSubProjects index 84c212a78..225c2df8d 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 84c212a78040457ca2fb88c998dc95c4758cb1f1 +Subproject commit 225c2df8df18a241aed931c81dd260ec55d44f8b From 9360e45a392c854b6200550d3fea71e16f5bc24a Mon Sep 17 00:00:00 2001 From: James Seibel Date: Wed, 4 Mar 2026 07:39:05 -0600 Subject: [PATCH 16/72] Add far fade --- .../common/renderTest/McFarFadeRenderer.java | 349 ++++++++ .../McGenericObjectRenderer_Textures.java | 779 ------------------ .../McInstancedVboContainer_Textures.java | 277 ------- .../common/renderTest/McSsaoRenderer.java | 5 - ...nderer.java => McVanillaFadeRenderer.java} | 9 +- .../common/wrappers/DependencySetup.java | 3 +- coreSubProjects | 2 +- 7 files changed, 356 insertions(+), 1068 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{McFadeRenderer.java => McVanillaFadeRenderer.java} (97%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java new file mode 100644 index 000000000..3b69e1b19 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java @@ -0,0 +1,349 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFarFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcVanillaFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; +import net.minecraft.client.Minecraft; +import net.minecraft.resources.Identifier; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * Renders a TODO + */ +public class McFarFadeRenderer implements IMcFarFadeRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + public static final McFarFadeRenderer INSTANCE = new McFarFadeRenderer(); + + private VertexFormat vertexFormat; + private RenderPipeline pipeline; + private boolean init = false; + + private GpuBuffer fragUniformBuffer; + + private GpuBuffer vboGpuBuffer; + + public GpuTexture fadeColorTexture; + + + + //=============// + // constructor // + //=============// + //region + + private McFarFadeRenderer() + { + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + } + + private void tryInit() + { + if (this.init) + { + return; + } + this.init = true; + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:far_fade")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/dh_fade")); + + pipelineBuilder.withSampler("uMcColorTexture"); + + pipelineBuilder.withSampler("uDhDepthTexture"); + pipelineBuilder.withSampler("uDhColorTexture"); + + pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + + + // upload vertex data + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + } + + //endregion + + + + //========// + // render // + //========// + //region + + @Override // TODO can probably just be DH mvm/proj matricies + public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + { + this.tryInit(); + + + if (McLodRenderer.INSTANCE.dhDepthTexture == null + || McLodRenderer.INSTANCE.dhColorTexture == null) + { + return; + } + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + + // textures + if (this.fadeColorTexture == null + || this.fadeColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() + || this.fadeColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) + { + if (this.fadeColorTexture != null) + { + this.fadeColorTexture.close(); + } + + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.fadeColorTexture = gpuDevice.createTexture("FadeColorTexture", + usage, + TextureFormat.RGBA8, + MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), + 1, 1 + ); + } + + + { + int uniformBufferSize = new Std140SizeCalculator() + .putFloat() // uStartFadeBlockDistance + .putFloat() // uEndFadeBlockDistance + .putMat4f() // uDhInvMvmProj + .get(); + + + // create data // + + float dhFarClipDistance = RenderUtil.getFarClipPlaneDistanceInBlocks(); + float fadeStartDistance = dhFarClipDistance * 0.5f; + float fadeEndDistance = dhFarClipDistance * 0.9f; + + + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + + Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); + inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); + inverseDhModelViewProjectionMatrix.invert(); + Mat4f inverseDhMvmProjMatrix = inverseDhModelViewProjectionMatrix; + + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putFloat(fadeStartDistance) // uStartFadeBlockDistance + .putFloat(fadeEndDistance) // uEndFadeBlockDistance + .putMat4f(inverseDhMvmProjMatrix.createJomlMatrix()) // uDhInvMvmProj + .get() + ; + + this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + this.renderFadeToTexture(); + McCopyRenderer.INSTANCE.render(this.fadeColorTexture, McLodRenderer.INSTANCE.dhColorTexture); + + } + + private void renderFadeToTexture() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McFadeRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(this.fadeColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = null; + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + + // render pass setup + { + // bind MC color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uMcColorTexture", textureView, gpuSampler); + } + + + // bind DH depth texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); + } + + // bind DH color texture + { + GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + GpuSampler gpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); + } + + + + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + + // bind VBO + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + // set pipeline + renderPass.setPipeline(this.pipeline); + } + + // draw render pass + { + int indexStart = 0; + int indexCount = 4; + renderPass.draw(indexStart, indexCount); + } + } + } + + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java deleted file mode 100644 index 176ff7975..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer_Textures.java +++ /dev/null @@ -1,779 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.renderTest; - -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.buffers.Std140Builder; -import com.mojang.blaze3d.buffers.Std140SizeCalculator; -import com.mojang.blaze3d.pipeline.BlendFunction; -import com.mojang.blaze3d.pipeline.RenderPipeline; -import com.mojang.blaze3d.platform.DepthTestFunction; -import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.shaders.UniformType; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderPass; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.AddressMode; -import com.mojang.blaze3d.textures.FilterMode; -import com.mojang.blaze3d.textures.GpuSampler; -import com.mojang.blaze3d.textures.GpuTextureView; -import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; -import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; -import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; -import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericObjectRenderEvent; -import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderCleanupEvent; -import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderSetupEvent; -import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.logging.f3.F3Screen; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; -import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; -import com.seibel.distanthorizons.core.render.renderer.generic.InstancedVboContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; -import com.seibel.distanthorizons.core.util.LodUtil; -import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; -import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; -import com.seibel.distanthorizons.coreapi.ModInfo; -import net.minecraft.resources.Identifier; -import org.lwjgl.system.MemoryUtil; - -import java.awt.*; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.ArrayList; -import java.util.Collection; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Supplier; - -/** - * Handles rendering generic groups of {@link DhApiRenderableBox}. - * - * @see IDhApiCustomRenderRegister - * @see DhApiRenderableBox - */ -public class McGenericObjectRenderer_Textures implements IMcGenericRenderer -{ - private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - - private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); - - /** - * Can be used to troubleshoot the renderer. - * If enabled several debug objects will render around (0,150,0). - */ - public static final boolean RENDER_DEBUG_OBJECTS = false; - - /** A box from 0,0,0 to 1,1,1 */ - private static final float[] BOX_VERTICES = { - //region - // Pos x y z - - // min X, vertical face - 0, 0, 0, - 1, 0, 0, - 1, 1, 0, - 0, 1, 0, - // max X, vertical face - 0, 1, 1, - 1, 1, 1, - 1, 0, 1, - 0, 0, 1, - - // min Z, vertical face - 0, 0, 1, - 0, 0, 0, - 0, 1, 0, - 0, 1, 1, - // max Z, vertical face - 1, 0, 1, - 1, 1, 1, - 1, 1, 0, - 1, 0, 0, - - // min Y, horizontal face - 0, 0, 1, - 1, 0, 1, - 1, 0, 0, - 0, 0, 0, - // max Y, horizontal face - 0, 1, 1, - 1, 1, 1, - 1, 1, 0, - 0, 1, 0, - //endregion - }; - - private static final int[] BOX_INDICES = { - //region - // min X, vertical face - 2, 1, 0, - 0, 3, 2, - // max X, vertical face - 6, 5, 4, - 4, 7, 6, - - // min Z, vertical face - 10, 9, 8, - 8, 11, 10, - // max Z, vertical face - 14, 13, 12, - 12, 15, 14, - - // min Y, horizontal face - 18, 17, 16, - 16, 19, 18, - // max Y, horizontal face - 20, 21, 22, - 22, 23, 20, - //endregion - }; - - private final ConcurrentHashMap boxGroupById = new ConcurrentHashMap<>(); - - - // rendering setup - private boolean init = false; - - private VertexFormat vertexFormat; - - private RenderPipeline opaquePipeline; - private RenderPipeline transparentPipeline; - - private GpuBuffer boxVertexBuffer; - private GpuBuffer boxIndexBuffer; - - private GpuBuffer fragUniformBuffer; - private GpuBuffer vertUniformBuffer; - - - - //=============// - // constructor // - //=============// - //region - - public McGenericObjectRenderer_Textures() { } - - public void init() - { - if (this.init) - { - return; - } - this.init = true; - - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) - .build(); - - this.createPipelines(); - this.createBuffers(); - - if (RENDER_DEBUG_OBJECTS) - { - this.addGenericDebugObjects(); - } - } - private void createPipelines() - { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); - { - pipelineBuilder.withCull(true); - pipelineBuilder.withDepthWrite(true); - pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); - pipelineBuilder.withColorWrite(true); - pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:generic")); - - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/frag")); - - pipelineBuilder.withSampler("uColorMap"); - - pipelineBuilder.withSampler("uLightMap"); - - pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); - - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); - } - - // opaque - { - pipelineBuilder.withoutBlend(); - this.opaquePipeline = pipelineBuilder.build(); - } - - // transparent - { - pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); - this.transparentPipeline = pipelineBuilder.build(); - } - - } - private void createBuffers() - { - // box vertices - ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); - boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); - boxVerticesBuffer.rewind(); - MemoryUtil.memFree(boxVerticesBuffer); - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // upload vertex data - { - Supplier labelSupplier = () -> "distantHorizons:McGenericRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = BOX_VERTICES.length * Float.BYTES; - this.boxVertexBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = BOX_VERTICES.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxVertexBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(BOX_VERTICES); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - - // box vertex indexes - { - ByteBuffer buffer = ByteBuffer.allocateDirect(BOX_INDICES.length * Integer.BYTES); - buffer.asIntBuffer().put(BOX_INDICES); - buffer.rewind(); - - - // TODO - // GpuBuffer.USAGE_UNIFORM = 128 - // GpuBuffer.USAGE_INDEX = 64 - int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.boxIndexBuffer = gpuDevice.createBuffer(() -> "DH Generic Index Buffer", usage, buffer.capacity()); - - int offset = 0; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxIndexBuffer, offset, buffer.capacity()); - commandEncoder.writeToBuffer(bufferSlice, buffer); - } - } - private void addGenericDebugObjects() - { - GenericRenderObjectFactory factory = GenericRenderObjectFactory.INSTANCE; - - - // single giant box - IDhApiRenderableBoxGroup singleGiantBoxGroup = factory.createForSingleBox( - ModInfo.NAME + ":CyanChunkBox", - new DhApiRenderableBox( - new DhApiVec3d(0,0,0), new DhApiVec3d(16,190,16), - new Color(Color.CYAN.getRed(), Color.CYAN.getGreen(), Color.CYAN.getBlue(), 125), - EDhApiBlockMaterial.WATER) - ); - singleGiantBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); - singleGiantBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); - this.add(singleGiantBoxGroup); - - - // single slender box - IDhApiRenderableBoxGroup singleTallBoxGroup = factory.createForSingleBox( - ModInfo.NAME + ":GreenBeacon", - new DhApiRenderableBox( - new DhApiVec3d(16,0,31), new DhApiVec3d(17,2000,32), - new Color(Color.GREEN.getRed(), Color.GREEN.getGreen(), Color.GREEN.getBlue(), 125), - EDhApiBlockMaterial.ILLUMINATED) - ); - singleTallBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); - singleTallBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); - this.add(singleTallBoxGroup); - - - // absolute box group - ArrayList absBoxList = new ArrayList<>(); - for (int i = 0; i < 18; i++) - { - absBoxList.add(new DhApiRenderableBox( - new DhApiVec3d(i,150+i,24), new DhApiVec3d(1+i,151+i,25), - new Color(Color.ORANGE.getRed(), Color.ORANGE.getGreen(), Color.ORANGE.getBlue()), - EDhApiBlockMaterial.LAVA - ) - ); - } - IDhApiRenderableBoxGroup absolutePosBoxGroup = factory.createAbsolutePositionedGroup(ModInfo.NAME + ":OrangeStairs", absBoxList); - this.add(absolutePosBoxGroup); - - - // relative box group - ArrayList relBoxList = new ArrayList<>(); - for (int i = 0; i < 8; i+=2) - { - relBoxList.add(new DhApiRenderableBox( - new DhApiVec3d(0,i,0), new DhApiVec3d(1,1+i,1), - new Color(Color.MAGENTA.getRed(), Color.MAGENTA.getGreen(), Color.MAGENTA.getBlue()), - EDhApiBlockMaterial.METAL - ) - ); - } - IDhApiRenderableBoxGroup relativePosBoxGroup = factory.createRelativePositionedGroup( - ModInfo.NAME + ":MovingMagentaGroup", - new DhApiVec3d(24, 140, 24), - relBoxList); - relativePosBoxGroup.setPreRenderFunc((event) -> - { - DhApiVec3d pos = relativePosBoxGroup.getOriginBlockPos(); - pos.x += event.partialTicks / 2; - pos.x %= 32; - relativePosBoxGroup.setOriginBlockPos(pos); - }); - this.add(relativePosBoxGroup); - - - // massive relative box group - ArrayList massRelBoxList = new ArrayList<>(); - for (int x = 0; x < 50*2; x+=2) - { - for (int z = 0; z < 50*2; z+=2) - { - massRelBoxList.add(new DhApiRenderableBox( - new DhApiVec3d(-x, 0, -z), new DhApiVec3d(1-x, 1, 1-z), - new Color(Color.RED.getRed(), Color.RED.getGreen(), Color.RED.getBlue()), - EDhApiBlockMaterial.TERRACOTTA - ) - ); - } - } - IDhApiRenderableBoxGroup massRelativePosBoxGroup = factory.createRelativePositionedGroup( - ModInfo.NAME + ":MassRedGroup", - new DhApiVec3d(-25, 140, 0), - massRelBoxList); - massRelativePosBoxGroup.setPreRenderFunc((event) -> - { - DhApiVec3d blockPos = massRelativePosBoxGroup.getOriginBlockPos(); - blockPos.y += event.partialTicks / 4; - if (blockPos.y > 150f) - { - blockPos.y = 140f; - - Color newColor = (massRelativePosBoxGroup.get(0).color == Color.RED) ? Color.RED.darker() : Color.RED; - massRelativePosBoxGroup.forEach((box) -> { box.color = newColor; }); - massRelativePosBoxGroup.triggerBoxChange(); - } - - massRelativePosBoxGroup.setOriginBlockPos(blockPos); - }); - this.add(massRelativePosBoxGroup); - } - - //endregion - - - - //==============// - // registration // - //==============// - //region - - @Override - public void add(IDhApiRenderableBoxGroup iBoxGroup) throws IllegalArgumentException - { - if (!(iBoxGroup instanceof RenderableBoxGroup)) - { - throw new IllegalArgumentException("Box group must be of type ["+ RenderableBoxGroup.class.getSimpleName()+"], type received: ["+(iBoxGroup != null ? iBoxGroup.getClass() : "NULL")+"]."); - } - RenderableBoxGroup boxGroup = (RenderableBoxGroup) iBoxGroup; - - - long id = boxGroup.getId(); - if (this.boxGroupById.containsKey(id)) - { - throw new IllegalArgumentException("A box group with the ID [" + id + "] is already present."); - } - - this.boxGroupById.put(id, boxGroup); - } - - @Override - public IDhApiRenderableBoxGroup remove(long id) { return this.boxGroupById.remove(id); } - - public void clear() { this.boxGroupById.clear(); } - - //endregion - - - - //===========// - // rendering // - //===========// - //region - - /** - * @param renderingWithSsao - * if true that means this render call is happening before the SSAO pass - * and any objects rendered in this pass will have SSAO applied to them. - */ - @Override - public void render(RenderParams renderEventParam, IProfilerWrapper profiler, boolean renderingWithSsao) - { - //==============// - // render setup // - //==============// - //#region - - profiler.push("setup"); - - this.init(); - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderSetupEvent.class, renderEventParam); - - Vec3d camPos = MC_RENDER.getCameraExactPosition(); - - //#endregion - - if (McLodRenderer.INSTANCE.dhColorTexture == null - || McLodRenderer.INSTANCE.dhDepthTexture == null) - { - return; - } - - - - //===========// - // rendering // - //===========// - //#region - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - Collection boxList = this.boxGroupById.values(); - for (RenderableBoxGroup boxGroup : boxList) - { - // validation // - - // shouldn't happen, but just in case - if (boxGroup == null) - { - continue; - } - - // skip boxes that shouldn't render this pass - if (boxGroup.ssaoEnabled != renderingWithSsao) - { - continue; - } - - profiler.popPush("render prep"); - boxGroup.preRender(renderEventParam); // called even if the group is inactive, so the group can be activate if desired - - // ignore inactive groups - if (!boxGroup.active) - { - continue; - } - - // allow API users to cancel this object's rendering - boolean cancelRendering = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericObjectRenderEvent.class, new DhApiBeforeGenericObjectRenderEvent.EventParam(renderEventParam, boxGroup)); - if (cancelRendering) - { - continue; - } - - // update instanced data if needed - { - boxGroup.tryUpdateInstancedDataAsync(); - - // skip groups that haven't been uploaded yet - if (boxGroup.instancedVbos.getState() != InstancedVboContainer.EState.RENDER) - { - continue; - } - } - - - DhApiRenderableBoxGroupShading shading = boxGroup.shading; - if (shading == null) - { - shading = DEFAULT_SHADING; - } - - // uniforms - { - int uniformBufferSize = new Std140SizeCalculator() - .putIVec3() // uOffsetChunk - .putVec3() // uOffsetSubChunk - .putIVec3() // uCameraPosChunk - .putVec3() // uCameraPosSubChunk - - .putMat4f() // uProjectionMvm - .putInt() // uSkyLight - .putInt() // uBlockLight - - .putFloat() // uNorthShading - .putFloat() // uSouthShading - .putFloat() // uEastShading - .putFloat() // uWestShading - .putFloat() // uTopShading - .putFloat() // uBottomShading - .get(); - - - // create data // - - Mat4f projectionMvmMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); - projectionMvmMatrix.multiply(renderEventParam.dhModelViewMatrix); - - - // upload data // - - ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); - buffer = Std140Builder.intoBuffer(buffer) - .putIVec3( - LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().x), - LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().y), - LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().z) - ) // uOffsetChunk - .putVec3( - LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().x), - LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().y), - LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().z) - ) // uOffsetSubChunk - .putIVec3( - LodUtil.getChunkPosFromDouble(camPos.x), - LodUtil.getChunkPosFromDouble(camPos.y), - LodUtil.getChunkPosFromDouble(camPos.z) - ) // uCameraPosChunk - .putVec3( - LodUtil.getSubChunkPosFromDouble(camPos.x), - LodUtil.getSubChunkPosFromDouble(camPos.y), - LodUtil.getSubChunkPosFromDouble(camPos.z) - ) // uCameraPosSubChunk - - .putMat4f(projectionMvmMatrix.createJomlMatrix()) // uProjectionMvm - .putInt(boxGroup.getSkyLight()) // uSkyLight - .putInt(boxGroup.getBlockLight()) // uBlockLight - - .putFloat(shading.north) - .putFloat(shading.south) - .putFloat(shading.east) - .putFloat(shading.west) - .putFloat(shading.top) - .putFloat(shading.bottom) - - .get() - ; - - this.fragUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.fragUniformBuffer); - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - - commandEncoder.writeToBuffer(bufferSlice, buffer); - } - - - - - // render // - - profiler.popPush("rendering"); - profiler.push(boxGroup.getResourceLocationNamespace()); - profiler.push(boxGroup.getResourceLocationPath()); - - Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) - { - this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); - } - - profiler.pop(); // resource path - profiler.pop(); // resource namespace - - boxGroup.postRender(renderEventParam); - } - - //#endregion - - - - //==========// - // clean up // - //==========// - //region - - profiler.popPush("cleanup"); - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderCleanupEvent.class, renderEventParam); - - profiler.pop(); - - //endregion - } - - //endregion - - - - //=====================// - // instanced rendering // - //=====================// - //region - - private void renderBoxGroupInstanced( - RenderPass renderPass, RenderParams renderEventParam, - RenderableBoxGroup boxGroup, Vec3d camPos, - IProfilerWrapper profiler) - { - // update instance data // - - profiler.push("vertex setup"); - - GpuDevice gpuDevice = RenderSystem.getDevice(); - - McInstancedVboContainer_Textures container = (McInstancedVboContainer_Textures) boxGroup.instancedVbos; - - - // bind MC Lightmap - { - LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - - GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uLightMap", textureView, gpuSampler); - } - - renderPass.setIndexBuffer(this.boxIndexBuffer, VertexFormat.IndexType.INT); - - - - // Bind instance data // - profiler.popPush("binding"); - { - GpuTextureView colorView = gpuDevice.createTextureView(container.colorTexture); - GpuSampler colorSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uColorMap", colorView, colorSampler); - - - renderPass.setVertexBuffer(0, this.boxVertexBuffer); - } - - renderPass.setUniform("vertUniformBlock", this.fragUniformBuffer); - - // set pipeline - renderPass.setPipeline(this.opaquePipeline); // TODO - - // Draw instanced - profiler.popPush("render"); - if (container.uploadedBoxCount > 0) - { - renderPass.drawIndexed( - /*indexStart*/ 0, - /*firstIndex*/0, - /*indexCount*/BOX_INDICES.length, - /*instanceCount*/container.uploadedBoxCount); - - } - - profiler.pop(); - } - - //endregion - - - - //=========// - // F3 menu // - //=========// - //region - - public String getVboRenderDebugMenuString() - { - // get counts - int totalGroupCount = this.boxGroupById.size(); - int totalBoxCount = 0; - - int activeGroupCount = 0; - int activeBoxCount = 0; - - for (long key : this.boxGroupById.keySet()) - { - RenderableBoxGroup renderGroup = this.boxGroupById.get(key); - if (renderGroup.active) - { - activeGroupCount++; - activeBoxCount += renderGroup.size(); - } - totalBoxCount += renderGroup.size(); - } - - - return "Generic Obj #: " + F3Screen.NUMBER_FORMAT.format(activeGroupCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalGroupCount) + ", " + - "Cube #: " + F3Screen.NUMBER_FORMAT.format(activeBoxCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalBoxCount); - } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java deleted file mode 100644 index a71d47641..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer_Textures.java +++ /dev/null @@ -1,277 +0,0 @@ -package com.seibel.distanthorizons.common.renderTest; - -import com.mojang.blaze3d.platform.NativeImage; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.GpuTexture; -import com.mojang.blaze3d.textures.TextureFormat; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.glObject.GLProxy; -import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; -import com.seibel.distanthorizons.core.util.LodUtil; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; - -import java.awt.*; -import java.nio.ByteBuffer; -import java.util.List; - - -/** - * For use by {@link RenderableBoxGroup} - * - * @see RenderableBoxGroup - */ -public class McInstancedVboContainer_Textures implements IInstancedVboContainer -{ - private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - - - - public GpuTexture colorTexture; - public GpuTexture scaleTexture; - public GpuTexture chunkPosXTexture; - public GpuTexture chunkPosYTexture; - public GpuTexture chunkPosZTexture; - public GpuTexture subChunkPosTexture; - public GpuTexture materialTexture; - - public int[] chunkPosData = new int[0]; - public float[] subChunkPosData = new float[0]; - public float[] scaleData = new float[0]; - public byte[] colorData = new byte[0]; - public int[] materialData = new int[0]; - - public int uploadedBoxCount = 0; - - private EState state = EState.NEW; - @Override - public EState getState() { return this.state; } - @Override - public void setState(EState state) { this.state = state; } - - - - //===========================// - // render building/uploading // - //===========================// - //region - - public void updateVertexData(List uploadBoxList) - { - int boxCount = uploadBoxList.size(); - - - // recreate the data arrays if their size is different - if (this.uploadedBoxCount != boxCount) - { - this.uploadedBoxCount = boxCount; - - this.chunkPosData = new int[boxCount * 3]; // 3 elements XYZ - this.subChunkPosData = new float[boxCount * 3]; // 3 elements XYZ - this.scaleData = new float[boxCount * 3]; // 3 elements XYZ - - this.colorData = new byte[boxCount * 4]; // 4 elements, RGBA - this.materialData = new int[boxCount]; - } - - - // transformation / scaling // - for (int i = 0; i < boxCount; i++) - { - DhApiRenderableBox box = uploadBoxList.get(i); - - int dataIndex = i * 3; - - this.chunkPosData[dataIndex] = LodUtil.getChunkPosFromDouble(box.minPos.x); - this.chunkPosData[dataIndex + 1] = LodUtil.getChunkPosFromDouble(box.minPos.y); - this.chunkPosData[dataIndex + 2] = LodUtil.getChunkPosFromDouble(box.minPos.z); - - this.subChunkPosData[dataIndex] = LodUtil.getSubChunkPosFromDouble(box.minPos.x); - this.subChunkPosData[dataIndex + 1] = LodUtil.getSubChunkPosFromDouble(box.minPos.y); - this.subChunkPosData[dataIndex + 2] = LodUtil.getSubChunkPosFromDouble(box.minPos.z); - - this.scaleData[dataIndex] = (float) (box.maxPos.x - box.minPos.x); - this.scaleData[dataIndex + 1] = (float) (box.maxPos.y - box.minPos.y); - this.scaleData[dataIndex + 2] = (float) (box.maxPos.z - box.minPos.z); - } - - - // colors/materials // - for (int i = 0; i < boxCount; i++) - { - DhApiRenderableBox box = uploadBoxList.get(i); - Color color = box.color; - int colorIndex = i * 4; - this.colorData[colorIndex] = (byte)color.getRed(); - this.colorData[colorIndex + 1] = (byte)color.getGreen(); - this.colorData[colorIndex + 2] = (byte)color.getBlue(); - this.colorData[colorIndex + 3] = (byte)color.getAlpha(); - - this.materialData[i] = box.material; - } - - this.state = EState.READY_TO_UPLOAD; - } - - public void uploadDataToGpu() - { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - if (this.colorTexture == null - || this.colorTexture.getWidth(0) < this.uploadedBoxCount) - { - // TODO USAGE_COPY_DST = 1 - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 1 | 4 | 8 | 32 | 128; - String texturePrefix = "DhGenericTexture_"; - - this.colorTexture = gpuDevice.createTexture(texturePrefix + "Color", - usage, - TextureFormat.RGBA8, - this.uploadedBoxCount, 1, - 1, 1 - ); - - this.scaleTexture = gpuDevice.createTexture(texturePrefix + "Scale", - usage, - TextureFormat.RGBA8, - this.uploadedBoxCount, 1, - 1, 1 - ); - - this.chunkPosXTexture = gpuDevice.createTexture(texturePrefix + "ChunkXPos", - usage, - TextureFormat.DEPTH32, - this.uploadedBoxCount, 1, - 1, 1 - ); - this.chunkPosYTexture = gpuDevice.createTexture(texturePrefix + "ChunkYPos", - usage, - TextureFormat.DEPTH32, - this.uploadedBoxCount, 1, - 1, 1 - ); - this.chunkPosZTexture = gpuDevice.createTexture(texturePrefix + "ChunkZPos", - usage, - TextureFormat.DEPTH32, - this.uploadedBoxCount, 1, - 1, 1 - ); - - this.subChunkPosTexture = gpuDevice.createTexture(texturePrefix + "SubChunk", - usage, - TextureFormat.RGBA8, - this.uploadedBoxCount, 1, - 1, 1 - ); - - //this.materialTexture = gpuDevice.createTexture(texturePrefix + "Material", - // usage, - // TextureFormat.RED8I, // TODO not valid? - // this.uploadedBoxCount, 1, - // 1, 1 - //); - } - - { - // color - { - ByteBuffer colorBuffer = ByteBuffer.allocateDirect(this.colorData.length * Float.BYTES); - colorBuffer.asFloatBuffer(); - - for (int i = 0; i < this.colorData.length; i++) - { - colorBuffer.put(this.colorData[i]); - } - colorBuffer.rewind(); - - commandEncoder.writeToTexture( - this.colorTexture, - colorBuffer, - NativeImage.Format.RGBA, // holds bytes - 0, //mipLevel - 0, // depthOrLayer - 0, // destX - 0, // destY - this.uploadedBoxCount, // width - 1 // height - ); - } - - // scale - { - ByteBuffer scaleBuffer = ByteBuffer.allocateDirect(this.scaleData.length * Float.BYTES); - scaleBuffer.asFloatBuffer(); - - for (int i = 0; i < this.scaleData.length; i++) - { scaleBuffer.putFloat(this.scaleData[i]); } - scaleBuffer.rewind(); - - commandEncoder.writeToTexture( - this.scaleTexture, - scaleBuffer, - NativeImage.Format.RGB, // holds bytes - 0, //mipLevel - 0, // depthOrLayer - 0, // destX - 0, // destY - this.uploadedBoxCount, // width - 1 // height - ); - } - - - //for (int i = 0; i < this.chunkPosData.length; i++) - //{ buffer.putInt(this.chunkPosData[i]); } - // - //for (int i = 0; i < this.subChunkPosData.length; i++) - //{ buffer.putFloat(this.subChunkPosData[i]); } - // - //for (int i = 0; i < this.colorData.length; i++) - //{ buffer.putFloat(this.colorData[i]); } - // - //for (int i = 0; i < this.materialData.length; i++) - //{ buffer.putInt(this.materialData[i]); } - // - //buffer.rewind(); - } - - this.state = EState.RENDER; - } - - //endregion - - - - //================// - // base overrides // - //================// - //region - - @Override - public void close() - { - GLProxy.queueRunningOnRenderThread(() -> - { - if (this.colorTexture != null) - { - this.colorTexture.close(); - } - }); - } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java index 0d2f0ceda..beb159994 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java @@ -34,18 +34,13 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; -import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import java.nio.ByteBuffer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java index 119b99cb3..d994cfcfb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java @@ -33,7 +33,6 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -42,7 +41,7 @@ import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcVanillaFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -56,14 +55,14 @@ import java.util.function.Supplier; /** * Renders a TODO */ -public class McFadeRenderer implements IMcFadeRenderer +public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - public static final McFadeRenderer INSTANCE = new McFadeRenderer(); + public static final McVanillaFadeRenderer INSTANCE = new McVanillaFadeRenderer(); private VertexFormat vertexFormat; private RenderPipeline pipeline; @@ -82,7 +81,7 @@ public class McFadeRenderer implements IMcFadeRenderer //=============// //region - private McFadeRenderer() + private McVanillaFadeRenderer() { this.vertexFormat = VertexFormat.builder() .add("vPosition", DhVertexFormat.SCREEN_POS) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 6db5157f0..135e5a81e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -75,10 +75,11 @@ public class DependencySetup public static void createRenderBindings() { SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcFadeRenderer.class, McFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, McVanillaFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, McFarFadeRenderer.INSTANCE); } } diff --git a/coreSubProjects b/coreSubProjects index 225c2df8d..c3dce412f 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 225c2df8df18a241aed931c81dd260ec55d44f8b +Subproject commit c3dce412fae3d4247a6852dc1ca64c9a49b83349 From 05d573c847544bf8456a0b02fe3641275171babd Mon Sep 17 00:00:00 2001 From: James Seibel Date: Wed, 4 Mar 2026 18:07:57 -0600 Subject: [PATCH 17/72] debug rendering --- .../renderTest/McDebugObjectRenderer.java | 362 ++++++++++++++++++ .../common/wrappers/DependencySetup.java | 1 + coreSubProjects | 2 +- 3 files changed, 364 insertions(+), 1 deletion(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java new file mode 100644 index 000000000..87a9a765f --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java @@ -0,0 +1,362 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.GpuTextureView; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.DebugRenderer; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcDebugRenderer; +import net.minecraft.resources.Identifier; +import org.lwjgl.system.MemoryUtil; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Collection; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO + */ +public class McDebugObjectRenderer implements IMcDebugRenderer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + public static McDebugObjectRenderer INSTANCE = new McDebugObjectRenderer(); + + + + /** A box from 0,0,0 to 1,1,1 */ + private static final float[] BOX_VERTICES = { + //region + // Pos x y z + 0, 0, 0, + 1, 0, 0, + 1, 1, 0, + 0, 1, 0, + 0, 0, 1, + 1, 0, 1, + 1, 1, 1, + 0, 1, 1, + //endregion + }; + + private static final int[] BOX_OUTLINE_INDICES = { + //region + 0, 1, + 1, 2, + 2, 3, + 3, 0, + + 4, 5, + 5, 6, + 6, 7, + 7, 4, + + 0, 4, + 1, 5, + 2, 6, + 3, 7, + //endregion + }; + + + + + // rendering setup + private boolean init = false; + + private VertexFormat vertexFormat; + + private RenderPipeline pipeline; + + private GpuBuffer boxVertexBuffer; + private GpuBuffer boxIndexBuffer; + + private GpuBuffer uniformBuffer; + + + //=============// + // constructor // + //=============// + //region + + public McDebugObjectRenderer() { } + + public void init() + { + if (this.init) + { + return; + } + this.init = true; + + this.vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) + .build(); + + this.createPipelines(); + this.createBuffers(); + + } + private void createPipelines() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + pipelineBuilder.withoutBlend(); + pipelineBuilder.withPolygonMode(PolygonMode.WIREFRAME); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:debug_renderer")); + + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/frag")); + + pipelineBuilder.withUniform("uniformBlock", UniformType.UNIFORM_BUFFER); + + pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.DEBUG_LINES); + } + this.pipeline = pipelineBuilder.build(); + + } + private void createBuffers() + { + // box vertices + ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); + boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); + boxVerticesBuffer.rewind(); + MemoryUtil.memFree(boxVerticesBuffer); + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + // upload vertex data + { + Supplier labelSupplier = () -> "distantHorizons:McDebugRenderer"; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = BOX_VERTICES.length * Float.BYTES; + this.boxVertexBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = BOX_VERTICES.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxVertexBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(BOX_VERTICES); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } + } + + // box vertex indexes + { + ByteBuffer buffer = ByteBuffer.allocateDirect(BOX_OUTLINE_INDICES.length * Integer.BYTES); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.asIntBuffer().put(BOX_OUTLINE_INDICES); + buffer.rewind(); + + + // TODO + // GpuBuffer.USAGE_UNIFORM = 128 + // GpuBuffer.USAGE_INDEX = 64 + int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + this.boxIndexBuffer = gpuDevice.createBuffer(() -> "DH Debug Index Buffer", usage, buffer.capacity()); + + int offset = 0; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxIndexBuffer, offset, buffer.capacity()); + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + } + + //endregion + + + + //===========// + // rendering // + //===========// + //region + + private Mat4f combinedMatrixThisFrame = new Mat4f(); + + @Override + public void render(RenderParams renderParams, Collection boxCollection) + { + + this.combinedMatrixThisFrame = new Mat4f(renderParams.dhProjectionMatrix); + this.combinedMatrixThisFrame.multiply(renderParams.dhModelViewMatrix); + + for (DebugRenderer.BoxParticle box : boxCollection) + { + this.render(box.createNewRenderBox()); + } + } + + @Override + public void render(DebugRenderer.Box box) + { + this.init(); + + if (McLodRenderer.INSTANCE.dhColorTexture == null + || McLodRenderer.INSTANCE.dhDepthTexture == null) + { + return; + } + + // shouldn't happen, but just in case + if (box == null) + { + return; + } + + + + + //===========// + // rendering // + //===========// + //#region + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + // validation // + + + // uniforms + { + int uniformBufferSize = new Std140SizeCalculator() + .putMat4f() // uTransform + .putVec4() // uColor + .get(); + + + // create data // + + Vec3d camPos = MC_RENDER.getCameraExactPosition(); + Vec3f camPosFloatThisFrame = new Vec3f((float) camPos.x, (float) camPos.y, (float) camPos.z); + + Mat4f boxTransform = Mat4f.createTranslateMatrix( + box.minPos.x - camPosFloatThisFrame.x, + box.minPos.y - camPosFloatThisFrame.y, + box.minPos.z - camPosFloatThisFrame.z); + boxTransform.multiply(Mat4f.createScaleMatrix( + box.maxPos.x - box.minPos.x, + box.maxPos.y - box.minPos.y, + box.maxPos.z - box.minPos.z)); + + Mat4f transformMatrix = this.combinedMatrixThisFrame.copy(); + transformMatrix.multiply(boxTransform); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer = Std140Builder.intoBuffer(buffer) + .putMat4f(transformMatrix.createJomlMatrix()) // uTransform + .putVec4( + box.color.getRed() / 255.0f, + box.color.getGreen() / 255.0f, + box.color.getBlue() / 255.0f, + box.color.getAlpha() / 255.0f) // uColor + .get() + ; + + this.uniformBuffer = UniformHandler.createBuffer("uniformBlock", uniformBufferSize, this.uniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.uniformBuffer, 0, uniformBufferSize); + + commandEncoder.writeToBuffer(bufferSlice, buffer); + } + + + + + // render // + + Supplier debugLabelSupplier = () -> "distantHorizons:McDebugRenderer"; + GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + + try (RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + colorTexture, + optionalClearColorAsInt, + depthTexture, optionalDepthValueAsDouble)) + { + // Bind instance data // + renderPass.setUniform("uniformBlock", this.uniformBuffer); + + // set pipeline + renderPass.setPipeline(this.pipeline); // TODO + renderPass.setIndexBuffer(this.boxIndexBuffer, VertexFormat.IndexType.INT); + + renderPass.setVertexBuffer(0, this.boxVertexBuffer); + + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/BOX_OUTLINE_INDICES.length, + /*instanceCount*/1); + } + //#endregion + + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 135e5a81e..65a352e1f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -80,6 +80,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, McFarFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, McDebugObjectRenderer.INSTANCE); } } diff --git a/coreSubProjects b/coreSubProjects index c3dce412f..2a554395f 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit c3dce412fae3d4247a6852dc1ca64c9a49b83349 +Subproject commit 2a554395f78b5872646d6ace51b22992bca233a3 From 3b5728692d18601c584aa4dabc813338bec621c0 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Thu, 5 Mar 2026 17:32:43 -0600 Subject: [PATCH 18/72] fix leak in LOD renderer and start separating uniforms --- .../AbstractUniformBufferWrapper.java | 83 +++++++ .../LodContainerUniformBufferWrapper.java | 63 ++++++ .../common/renderTest/McApplyRenderer.java | 66 +++--- .../common/renderTest/McLodRenderer.java | 209 +++++++++++------- .../common/renderTest/UniformHandler.java | 1 + .../common/wrappers/WrapperFactory.java | 20 +- coreSubProjects | 2 +- 7 files changed, 319 insertions(+), 125 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java new file mode 100644 index 000000000..2845b394b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java @@ -0,0 +1,83 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.function.Supplier; + +public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrapper +{ + private final String name; + + private ByteBuffer buffer = null; + public GpuBuffer gpuBuffer = null; + + + + //========// + // render // + //========// + //region + + public AbstractUniformBufferWrapper() { this.name = this.getClass().getSimpleName(); } + public AbstractUniformBufferWrapper(String name) { this.name = name; } + + protected ByteBuffer getOrCreateBuffer(int size) + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + + if (this.buffer == null + || this.buffer.capacity() != size) + { + this.buffer = ByteBuffer.allocateDirect(size); + this.buffer.order(ByteOrder.LITTLE_ENDIAN); + + // GpuBuffer.USAGE_UNIFORM = 128 + // GpuBuffer.USAGE_INDEX = 64 + int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int byteSize = (this.buffer.limit() - this.buffer.position()); + this.gpuBuffer = gpuDevice.createBuffer(this::getName, usage, byteSize); + } + + return this.buffer; + } + + @Override + public void upload() throws IllegalStateException + { + if (this.buffer == null) + { + throw new IllegalStateException("Upload called before buffer was created"); + } + + + + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + int byteSize = (this.buffer.limit() - this.buffer.position()); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.gpuBuffer, /*offset*/0, byteSize); + commandEncoder.writeToBuffer(bufferSlice, this.buffer); + } + private String getName() { return this.name; } + + @Override + public void close() + { + if (this.gpuBuffer != null) + { + this.gpuBuffer.close(); + } + } + + + + //endregion + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java new file mode 100644 index 000000000..e6794ceae --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java @@ -0,0 +1,63 @@ +package com.seibel.distanthorizons.common.renderTest; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.buffers.Std140Builder; +import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.pos.DhSectionPos; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.function.Supplier; + +public class LodContainerUniformBufferWrapper extends AbstractUniformBufferWrapper implements ILodContainerUniformBufferWrapper +{ + + + + + //========// + // ??? // + //========// + //region + + public void createBufferData(RenderParams renderEventParam, LodBufferContainer bufferContainer) + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelOffset = new Vec3f( + (float) (bufferContainer.minCornerBlockPos.getX() - camPos.x), + (float) (bufferContainer.minCornerBlockPos.getY() - camPos.y), + (float) (bufferContainer.minCornerBlockPos.getZ() - camPos.z)); + + + Mat4f combinedMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); + combinedMatrix.multiply(renderEventParam.dhModelViewMatrix); + + + // upload data // + + int uniformBufferSize = new Std140SizeCalculator() + .putVec3() // uModelOffset + .get(); + + ByteBuffer buffer = this.getOrCreateBuffer(uniformBufferSize); + Std140Builder.intoBuffer(buffer) + .putVec3(modelOffset.x, modelOffset.y, modelOffset.z) // uModelOffset + .get(); + + } + + //endregion + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java index 77dc8defe..eb86fd343 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java @@ -24,7 +24,6 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.shaders.UniformType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; @@ -36,7 +35,6 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -64,6 +62,14 @@ public class McApplyRenderer private GpuBuffer vboGpuBuffer; + private GpuTextureView dhColorTextureView; + private GpuSampler dhColorTextureSampler; + + private GpuTextureView dhDepthTextureView; + private GpuSampler dhDepthTextureSampler; + + private GpuTextureView mcColorTextureView; + //=============// // constructor // @@ -179,18 +185,45 @@ public class McApplyRenderer CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + { + GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); + if (this.mcColorTextureView == null + || this.mcColorTextureView.texture() != mcColorTexture) + { + this.mcColorTextureView = gpuDevice.createTextureView(mcColorTexture); + } + + + if (this.dhColorTextureSampler == null) + { + this.dhColorTextureSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + + this.dhDepthTextureSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + + } + // create a render pass { Supplier debugLabelSupplier = () -> "distantHorizons:McApplyRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); OptionalInt optionalClearColorAsInt = OptionalInt.empty(); GpuTextureView depthTexture = null; OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); try (RenderPass renderPass = commandEncoder.createRenderPass( debugLabelSupplier, - colorTexture, + this.mcColorTextureView, optionalClearColorAsInt, depthTexture, optionalDepthValueAsDouble)) { @@ -200,29 +233,8 @@ public class McApplyRenderer // render pass setup { - // bind color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); - } - - // bind depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } + renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureView, this.dhColorTextureSampler); + renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureView, this.dhDepthTextureSampler); // bind VBO renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index bd0f40e8f..921a957db 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -16,19 +16,20 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.pos.DhSectionPos; import com.seibel.distanthorizons.core.render.glObject.GLEnums; import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.objects.SortedArraySet; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; @@ -64,10 +65,17 @@ public class McLodRenderer implements IMcLodRenderer private GpuBuffer indexBuffer; private GpuBuffer fragUniformBuffer; - private GpuBuffer vertUniformBuffer; + private GpuBuffer vertSharedUniformBuffer; public GpuTexture dhDepthTexture; + public GpuTextureView dhDepthTextureView; + public GpuTexture dhColorTexture; + public GpuTextureView dhColorTextureView; + + private GpuTexture mcLightTexture; + private GpuTextureView mcLightTextureView; + private GpuSampler mcLightGpuSampler; @@ -117,7 +125,8 @@ public class McLodRenderer implements IMcLodRenderer pipelineBuilder.withSampler("uLightMap"); - pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); + pipelineBuilder.withUniform("vertUniqueUniformBlock", UniformType.UNIFORM_BUFFER); + pipelineBuilder.withUniform("vertSharedUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); @@ -134,9 +143,6 @@ public class McLodRenderer implements IMcLodRenderer pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); this.transparentPipeline = pipelineBuilder.build(); } - - - } //endregion @@ -155,8 +161,7 @@ public class McLodRenderer implements IMcLodRenderer public void render( RenderParams renderEventParam, boolean opaquePass, - DhApiVec3f modelOffset, - IVertexBufferWrapper[] bufferList, + SortedArraySet bufferContainers, IProfilerWrapper profiler) { this.tryInit(); @@ -168,10 +173,20 @@ public class McLodRenderer implements IMcLodRenderer - profiler.push("set vert uniforms"); + profiler.push("vert unique uniforms"); { // create data // + for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) + { + LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); + bufferContainer.uniforms.createBufferData(renderEventParam, bufferContainer); + bufferContainer.uniforms.upload(); + } + } + + profiler.popPush("vert share uniforms"); + { Mat4f combinedMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); combinedMatrix.multiply(renderEventParam.dhModelViewMatrix); @@ -196,33 +211,27 @@ public class McLodRenderer implements IMcLodRenderer .putFloat() // uMircoOffset .putFloat() // uEarthRadius - .putVec3() // uModelOffset - .putMat4f() // uCombinedMatrix .get(); ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); buffer.order(ByteOrder.LITTLE_ENDIAN); - buffer = Std140Builder.intoBuffer(buffer) + Std140Builder.intoBuffer(buffer) .putInt(0) // uIsWhiteWorld - .putFloat((float)renderEventParam.worldYOffset) // uWorldYOffset + .putFloat((float) renderEventParam.worldYOffset) // uWorldYOffset .putFloat(0.01f) // uMircoOffset // 0.01 block offset .putFloat(earthCurveRatio) // uEarthRadius - .putVec3(modelOffset.x, modelOffset.y, modelOffset.z) // uModelOffset - .putMat4f(combinedMatrix.createJomlMatrix()) // uCombinedMatrix .get(); - this.vertUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); + this.vertSharedUniformBuffer = UniformHandler.createBuffer("vertSharedUniformBlock", uniformBufferSize, this.vertSharedUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertSharedUniformBuffer, 0, uniformBufferSize); commandEncoder.writeToBuffer(bufferSlice, buffer); - } - profiler.popPush("set frag uniforms"); { int uniformBufferSize = new Std140SizeCalculator() @@ -297,7 +306,10 @@ public class McLodRenderer implements IMcLodRenderer if (this.dhDepthTexture != null) { this.dhDepthTexture.close(); + this.dhDepthTextureView.close(); + this.dhColorTexture.close(); + this.dhDepthTextureView.close(); } // TODO USAGE_TEXTURE_BINDING = 4 @@ -308,97 +320,124 @@ public class McLodRenderer implements IMcLodRenderer MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), 1, 1 ); + this.dhDepthTextureView = gpuDevice.createTextureView(this.dhDepthTexture); + this.dhColorTexture = gpuDevice.createTexture("DhColorTexture", usage, TextureFormat.RGBA8, MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), 1, 1 ); + this.dhColorTextureView = gpuDevice.createTextureView(this.dhColorTexture); } - profiler.popPush("create render pass"); - - // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McLodRenderer"; - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try ( - GpuTextureView colorTextureView = gpuDevice.createTextureView(this.dhColorTexture); - GpuTextureView depthTextureView = gpuDevice.createTextureView(this.dhDepthTexture); - RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTextureView, - optionalClearColorAsInt, - depthTextureView, optionalDepthValueAsDouble)) + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + if (this.mcLightTexture != lightMapWrapper.gpuTexture) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // bind MC Lightmap + this.mcLightTexture = lightMapWrapper.gpuTexture; + if (this.mcLightTextureView != null) { - LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - - GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uLightMap", textureView, gpuSampler); + this.mcLightTextureView.close(); } - renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); - renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + this.mcLightTextureView = gpuDevice.createTextureView(this.mcLightTexture); + this.mcLightGpuSampler = gpuDevice.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + + + { + profiler.popPush("setup"); + // create a render pass + Supplier debugLabelSupplier = () -> "distantHorizons:McLodRenderer"; + OptionalInt optionalClearColorAsInt = OptionalInt.empty(); + OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - profiler.popPush("set pipeline"); - - renderPass.setPipeline(opaquePass ? this.opaquePipeline : this.transparentPipeline); - renderPass.setIndexBuffer(this.indexBuffer, VertexFormat.IndexType.INT); - - // render pass setup - for (int i = 0; i < bufferList.length; i++) + try(RenderPass renderPass = commandEncoder.createRenderPass( + debugLabelSupplier, + this.dhColorTextureView, + optionalClearColorAsInt, + this.dhDepthTextureView, optionalDepthValueAsDouble) + ) { - VertexBufferWrapper bufferWrapper = (VertexBufferWrapper)bufferList[i]; - if (!bufferWrapper.uploaded - || bufferWrapper.vertexCount == 0) + //renderPass.pushDebugGroup(); + //renderPass.popDebugGroup(); + + // bind MC Lightmap + renderPass.bindTexture("uLightMap", this.mcLightTextureView, this.mcLightGpuSampler); + + // set pipeline + renderPass.setPipeline(opaquePass ? this.opaquePipeline : this.transparentPipeline); + renderPass.setIndexBuffer(this.indexBuffer, VertexFormat.IndexType.INT); + + // shared uniforms + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); + renderPass.setUniform("vertSharedUniformBlock", this.vertSharedUniformBuffer); + + + + + for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) { - continue; - } - - profiler.popPush("set VBO"); - - renderPass.setVertexBuffer(0, bufferWrapper.vboGpuBuffer); // vertex buffer can only be "0" lol - - profiler.popPush("render"); - - try - { - renderPass.drawIndexed( - /*indexStart*/ 0, - /*firstIndex*/0, - /*indexCount*/bufferWrapper.indexCount, - /*instanceCount*/1); - } - catch (IllegalStateException e) - { - if (!e.getMessage().contains("Vertex buffer at slot 0 has been closed")) + profiler.popPush("binding"); + + LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); + LodContainerUniformBufferWrapper uniformWrapper = (LodContainerUniformBufferWrapper)bufferContainer.uniforms; + + boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get(); + if (columnBuilderDebugEnabled) { - throw new RuntimeException(e); + if (DhSectionPos.getDetailLevel(bufferContainer.pos) == Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugDetailLevel.get() + && DhSectionPos.getX(bufferContainer.pos) == Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugXPos.get() + && DhSectionPos.getZ(bufferContainer.pos) == Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugZPos.get()) + { + int breakpoint = 0; + } + else + { + continue; + } + } + + renderPass.setUniform("vertUniqueUniformBlock", uniformWrapper.gpuBuffer); + + + + profiler.popPush("rendering"); + + // render each buffer + IVertexBufferWrapper[] bufferWrapperList = opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent; + for (int i = 0; i < bufferWrapperList.length; i++) + { + VertexBufferWrapper bufferWrapper = (VertexBufferWrapper) bufferWrapperList[i]; + if (!bufferWrapper.uploaded + || bufferWrapper.vertexCount == 0) + { + continue; + } + + //ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + + renderPass.setVertexBuffer(0, bufferWrapper.vboGpuBuffer); // vertex buffer can only be "0" lol + + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/bufferWrapper.indexCount, + /*instanceCount*/1); } } } } - - profiler.pop(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java index dd4c73a00..acf0b0f65 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java @@ -4,6 +4,7 @@ import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; +@Deprecated // TODO use Uniform Wrapper instead public class UniformHandler { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 9ec50b096..82e2aa46a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,6 +24,7 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; +import com.seibel.distanthorizons.common.renderTest.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.renderTest.McGenericObjectRenderer; import com.seibel.distanthorizons.common.renderTest.McInstancedVboContainer; import com.seibel.distanthorizons.common.renderTest.VertexBufferWrapper; @@ -40,7 +41,9 @@ import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; @@ -363,22 +366,15 @@ public class WrapperFactory implements IWrapperFactory @Override - public IVertexBufferWrapper createVboWrapper() - { - return new VertexBufferWrapper(); - } + public IVertexBufferWrapper createVboWrapper() { return new VertexBufferWrapper(); } + @Override + public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodContainerUniformBufferWrapper(); } @Override - public IInstancedVboContainer createInstancedVboContainer() - { - return new McInstancedVboContainer(); - } + public IInstancedVboContainer createInstancedVboContainer() { return new McInstancedVboContainer(); } @Override - public IMcGenericRenderer createGenericRenderer() - { - return new McGenericObjectRenderer(); - } + public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } diff --git a/coreSubProjects b/coreSubProjects index 2a554395f..0f539f3a6 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 2a554395f78b5872646d6ace51b22992bca233a3 +Subproject commit 0f539f3a6f9ca370dab13c51115e6708211f7fc9 From 766a41ce568395a2136105769a689e29a0cbde7f Mon Sep 17 00:00:00 2001 From: James Seibel Date: Thu, 5 Mar 2026 20:11:10 -0600 Subject: [PATCH 19/72] rearrange new renderers --- .../common/renderTest/McDebugObjectRenderer.java | 2 ++ .../common/renderTest/McGenericObjectRenderer.java | 3 +++ .../common/renderTest/McLodRenderer.java | 5 +++++ .../renderTest/{ => apply}/McApplyRenderer.java | 4 +++- .../renderTest/{ => apply}/McCopyRenderer.java | 4 ++-- .../{ => helpers}/AbstractUniformBufferWrapper.java | 3 +-- .../renderTest/{ => helpers}/DhVertexFormat.java | 2 +- .../LodContainerUniformBufferWrapper.java | 12 +----------- .../{ => helpers}/McInstancedVboContainer.java | 5 +---- .../renderTest/{ => helpers}/UniformHandler.java | 2 +- .../{ => helpers}/VertexBufferWrapper.java | 2 +- .../{ => postProcessing}/McFarFadeRenderer.java | 9 +++++---- .../{ => postProcessing}/McFogApplyRenderer.java | 4 +++- .../{ => postProcessing}/McFogRenderer.java | 6 ++++-- .../{ => postProcessing}/McSsaoApplyRenderer.java | 5 +++-- .../{ => postProcessing}/McSsaoRenderer.java | 5 ++++- .../{ => postProcessing}/McVanillaFadeRenderer.java | 6 +++++- .../common/renderTest/{ => test}/McTestRenderer.java | 5 +++-- .../common/wrappers/DependencySetup.java | 5 +++++ .../common/wrappers/WrapperFactory.java | 9 +++------ 20 files changed, 56 insertions(+), 42 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => apply}/McApplyRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => apply}/McCopyRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/AbstractUniformBufferWrapper.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/DhVertexFormat.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/LodContainerUniformBufferWrapper.java (74%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/McInstancedVboContainer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/UniformHandler.java (92%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => helpers}/VertexBufferWrapper.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McFarFadeRenderer.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McFogApplyRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McFogRenderer.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McSsaoApplyRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McSsaoRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => postProcessing}/McVanillaFadeRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/{ => test}/McTestRenderer.java (97%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java index 87a9a765f..f4a6d0044 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java @@ -33,6 +33,8 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.GpuTextureView; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java index 6a0e58e94..b9c58706e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java @@ -43,6 +43,9 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeG import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index 921a957db..7f0e4067f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -16,6 +16,11 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.apply.McApplyRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.LodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; +import com.seibel.distanthorizons.common.renderTest.helpers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java index eb86fd343..7e0794014 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.apply; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -30,6 +30,8 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java index 1dd4242a4..4cdfc55a0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.apply; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -30,12 +30,12 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import java.nio.ByteBuffer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java index 2845b394b..3c78a2bd8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -9,7 +9,6 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWr import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.util.function.Supplier; public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrapper { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java index 06b5dec3a..a687124b3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; import com.mojang.blaze3d.vertex.VertexFormatElement; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java similarity index 74% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java index e6794ceae..faa19377f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/LodContainerUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java @@ -1,25 +1,15 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderSystem; -import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; -import com.seibel.distanthorizons.core.pos.DhSectionPos; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.function.Supplier; public class LodContainerUniformBufferWrapper extends AbstractUniformBufferWrapper implements ILodContainerUniformBufferWrapper { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java index dabe0f385..58f147a6b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McInstancedVboContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -6,20 +6,17 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.glObject.GLEnums; import com.seibel.distanthorizons.core.render.glObject.GLProxy; -import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -import org.lwjgl.system.MemoryUtil; import java.nio.ByteBuffer; import java.nio.ByteOrder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java similarity index 92% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java index acf0b0f65..ebc4295bb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java index 269d4f554..44552b0c3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java index 3b69e1b19..2e0a85cbb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -33,7 +33,10 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -42,8 +45,6 @@ import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFarFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcVanillaFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java index 830c424f9..904236fef 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -36,6 +36,8 @@ import com.mojang.blaze3d.textures.FilterMode; import com.mojang.blaze3d.textures.GpuSampler; import com.mojang.blaze3d.textures.GpuTextureView; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java index 0aec345a0..f77ecad40 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -37,6 +37,9 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -47,7 +50,6 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFogRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; import net.minecraft.resources.Identifier; import java.awt.*; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java index e6a0f66dd..5d6c5ae75 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -36,12 +36,13 @@ import com.mojang.blaze3d.textures.FilterMode; import com.mojang.blaze3d.textures.GpuSampler; import com.mojang.blaze3d.textures.GpuTextureView; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import java.nio.ByteBuffer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java index beb159994..0baa4ef43 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -34,6 +34,9 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java index d994cfcfb..08f93e3f1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -33,6 +33,10 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java index 295f1e719..dcd49105a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.renderTest.test; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -30,6 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -109,7 +110,7 @@ public class McTestRenderer implements IMcTestRenderer pipelineBuilder.withDepthWrite(false); pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); pipelineBuilder.withColorWrite(true); - //builder.withBlend(BlendFunction.OVERLAY); + pipelineBuilder.withoutBlend(); pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 65a352e1f..d6e345311 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -20,6 +20,11 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.common.renderTest.*; +import com.seibel.distanthorizons.common.renderTest.postProcessing.McFarFadeRenderer; +import com.seibel.distanthorizons.common.renderTest.postProcessing.McFogRenderer; +import com.seibel.distanthorizons.common.renderTest.postProcessing.McSsaoRenderer; +import com.seibel.distanthorizons.common.renderTest.postProcessing.McVanillaFadeRenderer; +import com.seibel.distanthorizons.common.renderTest.test.McTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 82e2aa46a..798e4c559 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,10 +24,10 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; -import com.seibel.distanthorizons.common.renderTest.LodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.renderTest.McGenericObjectRenderer; -import com.seibel.distanthorizons.common.renderTest.McInstancedVboContainer; -import com.seibel.distanthorizons.common.renderTest.VertexBufferWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.renderTest.helpers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; @@ -43,7 +43,6 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrappe import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; @@ -55,13 +54,11 @@ import net.minecraft.core.Holder; #endif import net.minecraft.server.level.ServerLevel; import net.minecraft.world.level.Level; -import net.minecraft.world.level.LevelReader; import net.minecraft.world.level.biome.Biome; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.chunk.ChunkAccess; import java.io.IOException; -import java.util.HashSet; /** * This handles creating abstract wrapper objects. From ba0835bf4a3bac429cd945cd312e3845c682b27d Mon Sep 17 00:00:00 2001 From: James Seibel Date: Thu, 5 Mar 2026 20:19:44 -0600 Subject: [PATCH 20/72] Cleanup test renderer --- ...cTestRenderer.java => DhTestRenderer.java} | 134 +++++++----------- .../common/wrappers/DependencySetup.java | 4 +- 2 files changed, 57 insertions(+), 81 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/{McTestRenderer.java => DhTestRenderer.java} (58%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java similarity index 58% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java index dcd49105a..dde624fd3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/McTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java @@ -31,11 +31,8 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -47,35 +44,31 @@ import java.util.OptionalInt; import java.util.function.Supplier; /** - * Renders a UV colored quad + * Renders the OpenGL/Vulkan triangle * to the center of the screen to confirm DH's * apply shader is running correctly */ -public class McTestRenderer implements IMcTestRenderer +public class DhTestRenderer implements IMcTestRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + public static final DhTestRenderer INSTANCE = new DhTestRenderer(); - public static final McTestRenderer INSTANCE = new McTestRenderer(); - - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; + private GpuTextureView mcColorTextureView; + private GpuBuffer vboGpuBuffer; + //=============// // constructor // //=============// //region - private McTestRenderer() - { - - } + private DhTestRenderer() { } private void tryInit() { @@ -91,7 +84,7 @@ public class McTestRenderer implements IMcTestRenderer CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - this.vertexFormat = VertexFormat.builder() + VertexFormat vertexFormat = VertexFormat.builder() .add("vPosition", DhVertexFormat.SCREEN_POS) .add("vColor", DhVertexFormat.RGBA_FLOAT_COLOR) .build(); @@ -117,43 +110,51 @@ public class McTestRenderer implements IMcTestRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/frag")); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + pipelineBuilder.withVertexFormat(vertexFormat, VertexFormat.Mode.TRIANGLES); } this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for the OpenGL/Vulkan Triangle - float[] vertices = new float[] - { - // PosX,Y, ColorR,G,B,A - -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, - 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, - 0.0f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McTestRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } + this.mcColorTextureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + + this.uploadVertexData(); + } + private void uploadVertexData() + { + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); + + + // vertices for the OpenGL/Vulkan Triangle + float[] vertices = new float[] + { + // PosX,Y, ColorR,G,B,A + -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, + 0.0f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:DhTestRenderer"; + // TODO + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + } } //endregion @@ -178,46 +179,21 @@ public class McTestRenderer implements IMcTestRenderer // create a render pass { - Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + GpuTextureView mcDepthTextureView = null; OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, + () -> "distantHorizons:DhTestRenderer", + this.mcColorTextureView, optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + mcDepthTextureView, optionalDepthValueAsDouble)) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // render pass setup - { - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } - - // draw render pass - { - int indexStart = 0; - int indexCount = 3; - renderPass.draw(indexStart, indexCount); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); + renderPass.setPipeline(this.pipeline); + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 3); } } - - // clear depth texture - { - //GpuTexture depthTex = Minecraft.getInstance().getMainRenderTarget().getDepthTexture(); - //double newDepth = 0; - //commandEncoder.clearDepthTexture(depthTex, newDepth); - } } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index d6e345311..d3d9b3827 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -24,7 +24,7 @@ import com.seibel.distanthorizons.common.renderTest.postProcessing.McFarFadeRend import com.seibel.distanthorizons.common.renderTest.postProcessing.McFogRenderer; import com.seibel.distanthorizons.common.renderTest.postProcessing.McSsaoRenderer; import com.seibel.distanthorizons.common.renderTest.postProcessing.McVanillaFadeRenderer; -import com.seibel.distanthorizons.common.renderTest.test.McTestRenderer; +import com.seibel.distanthorizons.common.renderTest.test.DhTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; @@ -79,7 +79,7 @@ public class DependencySetup public static void createRenderBindings() { - SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, McTestRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, DhTestRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, McVanillaFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); From 550f36e9fa9e6778de2c12f5130cdd3e648031fa Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sat, 7 Mar 2026 14:31:22 -0600 Subject: [PATCH 21/72] merge apply renderers --- .../common/renderTest/McLodRenderer.java | 19 +- .../renderTest/apply/DhApplyRenderer.java | 268 ++++++++++++++++++ .../renderTest/apply/McApplyRenderer.java | 262 ----------------- .../renderTest/apply/McCopyRenderer.java | 6 +- .../postProcessing/McFogApplyRenderer.java | 253 ----------------- .../postProcessing/McFogRenderer.java | 17 +- .../postProcessing/McSsaoApplyRenderer.java | 253 ----------------- .../postProcessing/McSsaoRenderer.java | 16 +- .../postProcessing/McVanillaFadeRenderer.java | 2 +- 9 files changed, 318 insertions(+), 778 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index 7f0e4067f..5744823e8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -16,7 +16,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.apply.McApplyRenderer; +import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; @@ -40,6 +40,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRen import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; +import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import org.lwjgl.opengl.GL32; import org.lwjgl.system.MemoryUtil; @@ -62,6 +63,9 @@ public class McLodRenderer implements IMcLodRenderer public static final McLodRenderer INSTANCE = new McLodRenderer(); + + private DhApplyRenderer applyRenderer; + private VertexFormat vertexFormat; private RenderPipeline opaquePipeline; private RenderPipeline transparentPipeline; @@ -111,6 +115,11 @@ public class McLodRenderer implements IMcLodRenderer this.init = true; // todo only set when succeeded (in case of exception) + this.applyRenderer = new DhApplyRenderer( + "dh_apply_to_mc", + null, + "apply/vert", "apply/frag" + ); GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); @@ -447,7 +456,13 @@ public class McLodRenderer implements IMcLodRenderer } @Override - public void applyToMcTexture() { McApplyRenderer.INSTANCE.render(); } + public void applyToMcTexture() + { + //McApplyRenderer.INSTANCE.render(); + + GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); + this.applyRenderer.render(this.dhColorTexture, this.dhDepthTexture, mcColorTexture); + } @Override public void clearDepth() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java new file mode 100644 index 000000000..4f0bb334b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java @@ -0,0 +1,268 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.renderTest.apply; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.pipeline.BlendFunction; +import com.mojang.blaze3d.pipeline.RenderPipeline; +import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderPass; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import net.minecraft.resources.Identifier; +import org.jetbrains.annotations.Nullable; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.OptionalDouble; +import java.util.OptionalInt; +import java.util.function.Supplier; + +/** + * TODO ??? + */ +public class DhApplyRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + private RenderPipeline pipeline; + + protected GpuBuffer vboGpuBuffer; + + protected final String identifierName; + public String getIdentifierName() { return this.identifierName; } + + @Nullable + private final BlendFunction blendFunction; + private final String vertexShaderPath; + private final String fragmentShaderPath; + + private GpuTextureView sourceColorTextureView; + private GpuSampler sourceColorSampler; + + private GpuTextureView sourceDepthTextureView; + private GpuSampler sourceDepthSampler; + + private GpuTextureView destinationColorTextureView; + + + + //=============// + // constructor // + //=============// + //region + + public DhApplyRenderer( + String name, + @Nullable BlendFunction blendFunction, + String vertexShaderPath, String fragmentShaderPath + ) + { + this.identifierName = "distanthorizons:"+name; + this.blendFunction = blendFunction; + + this.vertexShaderPath = vertexShaderPath; + this.fragmentShaderPath = fragmentShaderPath; + } + + private void tryInit( + GpuTexture sourceColorTexture, + GpuTexture sourceDepthTexture, + GpuTexture destinationColorTexture) + { + this.createPipeline(); + this.uploadVertexData(); + this.createTextureViews(sourceColorTexture, sourceDepthTexture, destinationColorTexture); + } + private void createPipeline() + { + if (this.pipeline != null) + { + return; + } + + VertexFormat vertexFormat = VertexFormat.builder() + .add("vPosition", DhVertexFormat.SCREEN_POS) + .build(); + + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); + { + pipelineBuilder.withCull(false); + pipelineBuilder.withDepthWrite(false); + pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); + pipelineBuilder.withColorWrite(true); + + if (this.blendFunction != null) + { + pipelineBuilder.withBlend(this.blendFunction); + } + else + { + pipelineBuilder.withoutBlend(); + } + + pipelineBuilder.withPolygonMode(PolygonMode.FILL); + pipelineBuilder.withLocation(Identifier.parse(this.identifierName)); // TODO will complain if capital letters are included + + // TODO manually validate paths to confirm they exist and end with ".fsh" or ".vsh", MC silently fails if the files are missing/improperly named + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", this.vertexShaderPath)); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", this.fragmentShaderPath)); + + pipelineBuilder.withSampler("uSourceColorTexture"); + pipelineBuilder.withSampler("uSourceDepthTexture"); + + pipelineBuilder.withVertexFormat(vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + } + this.pipeline = pipelineBuilder.build(); + } + private void uploadVertexData() + { + // vertices for a full-screen quad + float[] vertices = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + Supplier labelSupplier = () -> "distantHorizons:"+this.identifierName; + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = vertices.length * Float.BYTES; + this.vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); + + { + int offset = 0; + int length = vertices.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(vertices); + byteBuffer.rewind(); + + COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); + } + } + private void createTextureViews( + GpuTexture sourceColorTexture, + GpuTexture sourceDepthTexture, + GpuTexture destinationColorTexture) + { + + // source color + if (this.sourceColorTextureView == null + || this.sourceColorTextureView.texture() != sourceColorTexture) + { + if (this.sourceColorTextureView != null) + { + this.sourceColorTextureView.close(); + } + + this.sourceColorTextureView = GPU_DEVICE.createTextureView(sourceColorTexture); + this.sourceColorSampler = GPU_DEVICE.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + + // source depth + if (this.sourceDepthTextureView == null + || this.sourceDepthTextureView.texture() != sourceDepthTexture) + { + if (this.sourceDepthTextureView != null) + { + this.sourceDepthTextureView.close(); + } + + this.sourceDepthTextureView = GPU_DEVICE.createTextureView(sourceDepthTexture); + this.sourceDepthSampler = GPU_DEVICE.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + + // destination color + if (this.destinationColorTextureView == null + || this.destinationColorTextureView.texture() != destinationColorTexture) + { + if (this.destinationColorTextureView != null) + { + this.destinationColorTextureView.close(); + } + + this.destinationColorTextureView = GPU_DEVICE.createTextureView(destinationColorTexture); + } + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render( + GpuTexture sourceColorTexture, + GpuTexture sourceDepthTexture, + GpuTexture destinationColorTexture) + { + this.tryInit(sourceColorTexture, sourceDepthTexture, destinationColorTexture); + + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getIdentifierName, + this.destinationColorTextureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) + { + renderPass.bindTexture("uSourceColorTexture", this.sourceColorTextureView, this.sourceColorSampler); + renderPass.bindTexture("uSourceDepthTexture", this.sourceDepthTextureView, this.sourceDepthSampler); + + renderPass.setVertexBuffer(0, this.vboGpuBuffer); + renderPass.setPipeline(this.pipeline); + + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); + } + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java deleted file mode 100644 index 7e0794014..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McApplyRenderer.java +++ /dev/null @@ -1,262 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.renderTest.apply; - -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.pipeline.RenderPipeline; -import com.mojang.blaze3d.platform.DepthTestFunction; -import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderPass; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; -import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import net.minecraft.client.Minecraft; -import net.minecraft.resources.Identifier; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.function.Supplier; - -/** - * TODO ??? - */ -public class McApplyRenderer -{ - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - - public static final McApplyRenderer INSTANCE = new McApplyRenderer(); - - private VertexFormat vertexFormat; - private RenderPipeline pipeline; - private boolean init = false; - - private GpuBuffer vboGpuBuffer; - - private GpuTextureView dhColorTextureView; - private GpuSampler dhColorTextureSampler; - - private GpuTextureView dhDepthTextureView; - private GpuSampler dhDepthTextureSampler; - - private GpuTextureView mcColorTextureView; - - - //=============// - // constructor // - //=============// - //region - - private McApplyRenderer() - { - - } - - private void tryInit() - { - if (this.init) - { - return; - } - this.init = true; - - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) - .build(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); - { - pipelineBuilder.withCull(false); - pipelineBuilder.withDepthWrite(false); - pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); - pipelineBuilder.withColorWrite(true); - pipelineBuilder.withoutBlend(); - pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:apply_render")); - - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "apply/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "apply/frag")); - - pipelineBuilder.withSampler("uDhColorTexture"); - pipelineBuilder.withSampler("uDhDepthTexture"); - - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); - } - this.pipeline = pipelineBuilder.build(); - - - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McApplyRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - - } - - //endregion - - - - //========// - // render // - //========// - //region - - public void render() - { - this.tryInit(); - - - if (McLodRenderer.INSTANCE.dhColorTexture == null) - { - return; - } - - if (McLodRenderer.INSTANCE.dhDepthTexture == null) - { - return; - } - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - { - GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); - if (this.mcColorTextureView == null - || this.mcColorTextureView.texture() != mcColorTexture) - { - this.mcColorTextureView = gpuDevice.createTextureView(mcColorTexture); - } - - - if (this.dhColorTextureSampler == null) - { - this.dhColorTextureSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - - this.dhDepthTextureSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - } - - } - - - // create a render pass - { - Supplier debugLabelSupplier = () -> "distantHorizons:McApplyRenderer"; - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - this.mcColorTextureView, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) - { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // render pass setup - { - renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureView, this.dhColorTextureSampler); - renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureView, this.dhDepthTextureSampler); - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } - - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } - } - } - } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java index 4cdfc55a0..d70c06e05 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java @@ -63,15 +63,13 @@ public class McCopyRenderer private GpuBuffer vboGpuBuffer; + //=============// // constructor // //=============// //region - private McCopyRenderer() - { - - } + private McCopyRenderer() { } private void tryInit() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java deleted file mode 100644 index 904236fef..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogApplyRenderer.java +++ /dev/null @@ -1,253 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.renderTest.postProcessing; - -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.pipeline.BlendFunction; -import com.mojang.blaze3d.pipeline.RenderPipeline; -import com.mojang.blaze3d.platform.DepthTestFunction; -import com.mojang.blaze3d.platform.DestFactor; -import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.platform.SourceFactor; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderPass; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.AddressMode; -import com.mojang.blaze3d.textures.FilterMode; -import com.mojang.blaze3d.textures.GpuSampler; -import com.mojang.blaze3d.textures.GpuTextureView; -import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import net.minecraft.resources.Identifier; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.function.Supplier; - -/** - * TODO ??? - */ -public class McFogApplyRenderer -{ - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - - public static final McFogApplyRenderer INSTANCE = new McFogApplyRenderer(); - - private VertexFormat vertexFormat; - private RenderPipeline pipeline; - private boolean init = false; - - private GpuBuffer vboGpuBuffer; - - - //=============// - // constructor // - //=============// - //region - - private McFogApplyRenderer() - { - - } - - private void tryInit() - { - if (this.init) - { - return; - } - this.init = true; - - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) - .build(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); - { - pipelineBuilder.withCull(false); - pipelineBuilder.withDepthWrite(false); - pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); - pipelineBuilder.withColorWrite(true); - pipelineBuilder.withBlend(new BlendFunction(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA)); - pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:fog_apply_render")); - - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/quad_apply")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/apply")); - - pipelineBuilder.withSampler("uColorTexture"); - pipelineBuilder.withSampler("uDhDepthTexture"); - - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); - } - this.pipeline = pipelineBuilder.build(); - - - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McFogApplyRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - - } - - //endregion - - - - //========// - // render // - //========// - //region - - public void render() - { - this.tryInit(); - - - if (McLodRenderer.INSTANCE.dhColorTexture == null) - { - return; - } - - if (McLodRenderer.INSTANCE.dhDepthTexture == null) - { - return; - } - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - - // create a render pass - { - Supplier debugLabelSupplier = () -> "distantHorizons:McApplyFogRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) - { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // render pass setup - { - // bind fog color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McFogRenderer.INSTANCE.fogColorTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uColorTexture", textureView, gpuSampler); - } - - // bind DH LOD depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } - - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } - } - } - } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java index f77ecad40..5998f078f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java @@ -23,9 +23,12 @@ import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.DestFactor; import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.platform.SourceFactor; import com.mojang.blaze3d.shaders.UniformType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; @@ -37,6 +40,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; @@ -72,6 +76,9 @@ public class McFogRenderer implements IMcFogRenderer public static final McFogRenderer INSTANCE = new McFogRenderer(); + + private DhApplyRenderer applyRenderer; + private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -106,6 +113,14 @@ public class McFogRenderer implements IMcFogRenderer + + this.applyRenderer = new DhApplyRenderer( + "fog_apply_to_dh", + new BlendFunction(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA), + "apply/vert", "apply/frag" + ); + + GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); @@ -362,7 +377,7 @@ public class McFogRenderer implements IMcFogRenderer this.renderFogToTexture(); - McFogApplyRenderer.INSTANCE.render(); + this.applyRenderer.render(this.fogColorTexture, McLodRenderer.INSTANCE.dhDepthTexture, McLodRenderer.INSTANCE.dhColorTexture); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java deleted file mode 100644 index 5d6c5ae75..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoApplyRenderer.java +++ /dev/null @@ -1,253 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.renderTest.postProcessing; - -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.pipeline.BlendFunction; -import com.mojang.blaze3d.pipeline.RenderPipeline; -import com.mojang.blaze3d.platform.DepthTestFunction; -import com.mojang.blaze3d.platform.DestFactor; -import com.mojang.blaze3d.platform.PolygonMode; -import com.mojang.blaze3d.platform.SourceFactor; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderPass; -import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.AddressMode; -import com.mojang.blaze3d.textures.FilterMode; -import com.mojang.blaze3d.textures.GpuSampler; -import com.mojang.blaze3d.textures.GpuTextureView; -import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import net.minecraft.resources.Identifier; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.OptionalDouble; -import java.util.OptionalInt; -import java.util.function.Supplier; - -/** - * TODO ??? - */ -public class McSsaoApplyRenderer -{ - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - - public static final McSsaoApplyRenderer INSTANCE = new McSsaoApplyRenderer(); - - private VertexFormat vertexFormat; - private RenderPipeline pipeline; - private boolean init = false; - - private GpuBuffer vboGpuBuffer; - - - //=============// - // constructor // - //=============// - //region - - private McSsaoApplyRenderer() - { - - } - - private void tryInit() - { - if (this.init) - { - return; - } - this.init = true; - - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) - .build(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); - { - pipelineBuilder.withCull(false); - pipelineBuilder.withDepthWrite(false); - pipelineBuilder.withDepthTestFunction(DepthTestFunction.NO_DEPTH_TEST); - pipelineBuilder.withColorWrite(true); - pipelineBuilder.withBlend(new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE)); - pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:ssao_apply_render")); - - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/apply")); - - pipelineBuilder.withSampler("uSsaoColorTexture"); - pipelineBuilder.withSampler("uDhDepthTexture"); - - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); - } - this.pipeline = pipelineBuilder.build(); - - - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McApplyRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - - } - - //endregion - - - - //========// - // render // - //========// - //region - - public void render() - { - this.tryInit(); - - - if (McLodRenderer.INSTANCE.dhColorTexture == null) - { - return; - } - - if (McLodRenderer.INSTANCE.dhDepthTexture == null) - { - return; - } - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - - // create a render pass - { - Supplier debugLabelSupplier = () -> "distantHorizons:McApplySsaoRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) - { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // render pass setup - { - // bind SSAO color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McSsaoRenderer.INSTANCE.ssaoColorTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uSsaoColorTexture", textureView, gpuSampler); - } - - // bind DH LOD depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } - - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } - } - } - } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java index 0baa4ef43..bea03b91e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java @@ -23,9 +23,12 @@ import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; +import com.mojang.blaze3d.platform.DestFactor; import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.platform.SourceFactor; import com.mojang.blaze3d.shaders.UniformType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; @@ -34,6 +37,7 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; @@ -64,6 +68,9 @@ public class McSsaoRenderer implements IMcSsaoRenderer public static final McSsaoRenderer INSTANCE = new McSsaoRenderer(); + + private DhApplyRenderer applyRenderer; + private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -97,6 +104,11 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.init = true; + this.applyRenderer = new DhApplyRenderer( + "ssao_apply_to_dh", + new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE), + "apply/vert", "ssao/apply" + ); GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); @@ -111,7 +123,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer pipelineBuilder.withColorWrite(true); pipelineBuilder.withoutBlend(); pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:ssao_render")); pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/ao")); @@ -259,7 +271,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.renderSsaoToTexture(); - McSsaoApplyRenderer.INSTANCE.render(); + this.applyRenderer.render(this.ssaoColorTexture, McLodRenderer.INSTANCE.dhDepthTexture, McLodRenderer.INSTANCE.dhColorTexture); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java index 08f93e3f1..52f5fc9b5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java @@ -115,7 +115,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer pipelineBuilder.withColorWrite(true); pipelineBuilder.withoutBlend(); pipelineBuilder.withPolygonMode(PolygonMode.FILL); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:mc_vanilla_fade_render")); pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vanilla_fade")); From 3f2d8ea6ae4961bd4b1d03c341063bb547c31c3e Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sat, 7 Mar 2026 14:32:08 -0600 Subject: [PATCH 22/72] merge apply renderers 2 --- coreSubProjects | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/coreSubProjects b/coreSubProjects index 0f539f3a6..e790bfb7e 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 0f539f3a6f9ca370dab13c51115e6708211f7fc9 +Subproject commit e790bfb7e8ed309a0f1a490b4fd4a74e05db5ca7 From da922a8c69853224d6ab5c4f01f28bb929492b6c Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sun, 8 Mar 2026 19:18:17 -0500 Subject: [PATCH 23/72] wrap GPU textures --- .../renderTest/McDebugObjectRenderer.java | 29 ++-- .../renderTest/McGenericObjectRenderer.java | 60 +++---- .../common/renderTest/McLodRenderer.java | 141 ++++------------- .../renderTest/apply/DhApplyRenderer.java | 84 +++------- .../renderTest/apply/McCopyRenderer.java | 94 +++++------ .../helpers/AbstractUniformBufferWrapper.java | 14 +- .../helpers/McTextureViewWrapper.java | 59 +++++++ .../renderTest/helpers/McTextureWrapper.java | 113 +++++++++++++ .../postProcessing/McFarFadeRenderer.java | 125 ++++----------- .../postProcessing/McFogRenderer.java | 100 +++--------- .../postProcessing/McSsaoRenderer.java | 101 +++--------- .../postProcessing/McVanillaFadeRenderer.java | 149 ++++-------------- .../renderTest/test/DhTestRenderer.java | 43 ++--- .../common/wrappers/misc/LightMapWrapper.java | 9 +- 14 files changed, 431 insertions(+), 690 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java index f4a6d0044..17a562cee 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java @@ -64,6 +64,9 @@ public class McDebugObjectRenderer implements IMcDebugRenderer private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + public static McDebugObjectRenderer INSTANCE = new McDebugObjectRenderer(); @@ -250,8 +253,8 @@ public class McDebugObjectRenderer implements IMcDebugRenderer { this.init(); - if (McLodRenderer.INSTANCE.dhColorTexture == null - || McLodRenderer.INSTANCE.dhDepthTexture == null) + if (McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -270,8 +273,6 @@ public class McDebugObjectRenderer implements IMcDebugRenderer //===========// //#region - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); // validation // @@ -318,25 +319,18 @@ public class McDebugObjectRenderer implements IMcDebugRenderer this.uniformBuffer = UniformHandler.createBuffer("uniformBlock", uniformBufferSize, this.uniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.uniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } - // render // - Supplier debugLabelSupplier = () -> "distantHorizons:McDebugRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { // Bind instance data // renderPass.setUniform("uniformBlock", this.uniformBuffer); @@ -356,6 +350,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer //#endregion } + private String getName() { return "distantHorizons:McDebugRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java index b9c58706e..db03e9489 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java @@ -45,6 +45,7 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -87,7 +88,9 @@ public class McGenericObjectRenderer implements IMcGenericRenderer private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); @@ -108,12 +111,10 @@ public class McGenericObjectRenderer implements IMcGenericRenderer private RenderPipeline opaquePipeline; private RenderPipeline transparentPipeline; - //private GpuBuffer boxVertexBuffer; - //private GpuBuffer boxIndexBuffer; - private GpuBuffer vertUniformBuffer; + //=============// // constructor // //=============// @@ -136,7 +137,6 @@ public class McGenericObjectRenderer implements IMcGenericRenderer .build(); this.createPipelines(); - //this.createBuffers(); if (RENDER_DEBUG_OBJECTS) { @@ -145,10 +145,6 @@ public class McGenericObjectRenderer implements IMcGenericRenderer } private void createPipelines() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(true); @@ -353,8 +349,8 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //#endregion - if (McLodRenderer.INSTANCE.dhColorTexture == null - || McLodRenderer.INSTANCE.dhDepthTexture == null) + if (McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -366,9 +362,6 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //===========// //#region - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - Collection boxList = this.boxGroupById.values(); for (RenderableBoxGroup boxGroup : boxList) { @@ -493,7 +486,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer this.vertUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } @@ -505,17 +498,12 @@ public class McGenericObjectRenderer implements IMcGenericRenderer profiler.push(boxGroup.getResourceLocationNamespace()); profiler.push(boxGroup.getResourceLocationPath()); - Supplier debugLabelSupplier = () -> "distantHorizons:McTestRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); } @@ -543,6 +531,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //endregion } + private String getName() { return "distantHorizons:McTestRenderer"; } //endregion @@ -562,24 +551,11 @@ public class McGenericObjectRenderer implements IMcGenericRenderer profiler.push("vertex setup"); - GpuDevice gpuDevice = RenderSystem.getDevice(); - McInstancedVboContainer container = (McInstancedVboContainer) boxGroup.instancedVbos; - - // bind MC Lightmap - { - LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - - GpuTextureView textureView = gpuDevice.createTextureView(lightMapWrapper.gpuTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uLightMap", textureView, gpuSampler); - } + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); + renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index 5744823e8..a1366e526 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -17,10 +17,7 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.LodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; -import com.seibel.distanthorizons.common.renderTest.helpers.VertexBufferWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.*; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; @@ -35,7 +32,6 @@ import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; @@ -59,7 +55,9 @@ public class McLodRenderer implements IMcLodRenderer public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final McLodRenderer INSTANCE = new McLodRenderer(); @@ -76,15 +74,8 @@ public class McLodRenderer implements IMcLodRenderer private GpuBuffer fragUniformBuffer; private GpuBuffer vertSharedUniformBuffer; - public GpuTexture dhDepthTexture; - public GpuTextureView dhDepthTextureView; - - public GpuTexture dhColorTexture; - public GpuTextureView dhColorTextureView; - - private GpuTexture mcLightTexture; - private GpuTextureView mcLightTextureView; - private GpuSampler mcLightGpuSampler; + public final McTextureWrapper dhDepthTextureWrapper = McTextureWrapper.createDepth("DhDepthTexture"); + public final McTextureWrapper dhColorTextureWrapper = McTextureWrapper.createColor("DhColorTexture"); @@ -121,9 +112,6 @@ public class McLodRenderer implements IMcLodRenderer "apply/vert", "apply/frag" ); - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { @@ -181,12 +169,6 @@ public class McLodRenderer implements IMcLodRenderer this.tryInit(); - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - profiler.push("vert unique uniforms"); { // create data // @@ -243,7 +225,7 @@ public class McLodRenderer implements IMcLodRenderer this.vertSharedUniformBuffer = UniformHandler.createBuffer("vertSharedUniformBlock", uniformBufferSize, this.vertSharedUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertSharedUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } profiler.popPush("set frag uniforms"); @@ -285,7 +267,7 @@ public class McLodRenderer implements IMcLodRenderer this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } // create index buffer @@ -303,89 +285,47 @@ public class McLodRenderer implements IMcLodRenderer // GpuBuffer.USAGE_UNIFORM = 128 // GpuBuffer.USAGE_INDEX = 64 int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.indexBuffer = gpuDevice.createBuffer(() -> "DH Index Buffer", usage, buffer.capacity()); + this.indexBuffer = GPU_DEVICE.createBuffer(() -> "DH Index Buffer", usage, buffer.capacity()); } int offset = 0; GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexBuffer, offset, buffer.capacity()); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } } // textures - if (this.dhDepthTexture == null - || this.dhDepthTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.dhDepthTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) - { - if (this.dhDepthTexture != null) - { - this.dhDepthTexture.close(); - this.dhDepthTextureView.close(); - - this.dhColorTexture.close(); - this.dhDepthTextureView.close(); - } - - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; - this.dhDepthTexture = gpuDevice.createTexture("DhDepthTexture", - usage, - TextureFormat.DEPTH32, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - this.dhDepthTextureView = gpuDevice.createTextureView(this.dhDepthTexture); - - this.dhColorTexture = gpuDevice.createTexture("DhColorTexture", - usage, - TextureFormat.RGBA8, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - this.dhColorTextureView = gpuDevice.createTextureView(this.dhColorTexture); - } + this.dhDepthTextureWrapper.trySetup(); + this.dhColorTextureWrapper.trySetup(); + + //LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + //this.mcLightTextureViewWrapper.trySetup(lightMapWrapper.gpuTexture); - LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - if (this.mcLightTexture != lightMapWrapper.gpuTexture) - { - this.mcLightTexture = lightMapWrapper.gpuTexture; - if (this.mcLightTextureView != null) - { - this.mcLightTextureView.close(); - } - - - this.mcLightTextureView = gpuDevice.createTextureView(this.mcLightTexture); - this.mcLightGpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - } + //LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + //McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); + //renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); { profiler.popPush("setup"); // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McLodRenderer"; OptionalInt optionalClearColorAsInt = OptionalInt.empty(); OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - try(RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - this.dhColorTextureView, + try(RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + this.dhColorTextureWrapper.textureView, optionalClearColorAsInt, - this.dhDepthTextureView, optionalDepthValueAsDouble) + this.dhDepthTextureWrapper.textureView, optionalDepthValueAsDouble) ) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - // bind MC Lightmap - renderPass.bindTexture("uLightMap", this.mcLightTextureView, this.mcLightGpuSampler); + //renderPass.bindTexture("uLightMap", this.mcLightTextureViewWrapper.textureView, this.mcLightTextureViewWrapper.textureSampler); + LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; + McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); + renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); // set pipeline renderPass.setPipeline(opaquePass ? this.opaquePipeline : this.transparentPipeline); @@ -397,7 +337,6 @@ public class McLodRenderer implements IMcLodRenderer - for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) { profiler.popPush("binding"); @@ -454,39 +393,19 @@ public class McLodRenderer implements IMcLodRenderer profiler.pop(); } + private String getName() { return "distantHorizons:McLodRenderer"; } @Override public void applyToMcTexture() { - //McApplyRenderer.INSTANCE.render(); - GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); - this.applyRenderer.render(this.dhColorTexture, this.dhDepthTexture, mcColorTexture); + this.applyRenderer.render(this.dhColorTextureWrapper.texture, this.dhDepthTextureWrapper.texture, mcColorTexture); } @Override - public void clearDepth() - { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - if (this.dhDepthTexture != null) - { - commandEncoder.clearDepthTexture(this.dhDepthTexture, 1.0f); - } - } - + public void clearDepth() { this.dhDepthTextureWrapper.clearDepth(1.0f); } @Override - public void clearColor() - { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - if (this.dhColorTexture != null) - { - commandEncoder.clearColorTexture(this.dhColorTexture, ColorUtil.argbToInt(1, 1, 1, 1)); - } - } + public void clearColor() { this.dhColorTextureWrapper.clearColor(ColorUtil.argbToInt(1, 1, 1, 1)); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java index 4f0bb334b..3d09de693 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java @@ -32,6 +32,8 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import net.minecraft.resources.Identifier; @@ -65,13 +67,10 @@ public class DhApplyRenderer private final String vertexShaderPath; private final String fragmentShaderPath; - private GpuTextureView sourceColorTextureView; - private GpuSampler sourceColorSampler; + private final McTextureViewWrapper sourceColorTextureViewWrapper = new McTextureViewWrapper(); + private final McTextureViewWrapper sourceDepthTextureViewWrapper = new McTextureViewWrapper(); - private GpuTextureView sourceDepthTextureView; - private GpuSampler sourceDepthSampler; - - private GpuTextureView destinationColorTextureView; + private final McTextureViewWrapper destinationColorTextureViewWrapper = new McTextureViewWrapper(); @@ -100,7 +99,12 @@ public class DhApplyRenderer { this.createPipeline(); this.uploadVertexData(); - this.createTextureViews(sourceColorTexture, sourceDepthTexture, destinationColorTexture); + + this.sourceColorTextureViewWrapper.trySetup(sourceColorTexture); + this.sourceDepthTextureViewWrapper.trySetup(sourceDepthTexture); + + this.destinationColorTextureViewWrapper.trySetup(destinationColorTexture); + } private void createPipeline() { @@ -175,60 +179,6 @@ public class DhApplyRenderer COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); } } - private void createTextureViews( - GpuTexture sourceColorTexture, - GpuTexture sourceDepthTexture, - GpuTexture destinationColorTexture) - { - - // source color - if (this.sourceColorTextureView == null - || this.sourceColorTextureView.texture() != sourceColorTexture) - { - if (this.sourceColorTextureView != null) - { - this.sourceColorTextureView.close(); - } - - this.sourceColorTextureView = GPU_DEVICE.createTextureView(sourceColorTexture); - this.sourceColorSampler = GPU_DEVICE.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - } - - // source depth - if (this.sourceDepthTextureView == null - || this.sourceDepthTextureView.texture() != sourceDepthTexture) - { - if (this.sourceDepthTextureView != null) - { - this.sourceDepthTextureView.close(); - } - - this.sourceDepthTextureView = GPU_DEVICE.createTextureView(sourceDepthTexture); - this.sourceDepthSampler = GPU_DEVICE.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - } - - // destination color - if (this.destinationColorTextureView == null - || this.destinationColorTextureView.texture() != destinationColorTexture) - { - if (this.destinationColorTextureView != null) - { - this.destinationColorTextureView.close(); - } - - this.destinationColorTextureView = GPU_DEVICE.createTextureView(destinationColorTexture); - } - } //endregion @@ -247,12 +197,14 @@ public class DhApplyRenderer this.tryInit(sourceColorTexture, sourceDepthTexture, destinationColorTexture); try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getIdentifierName, - this.destinationColorTextureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - /*depthTexture*/ null, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) + this::getIdentifierName, + this.destinationColorTextureViewWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - renderPass.bindTexture("uSourceColorTexture", this.sourceColorTextureView, this.sourceColorSampler); - renderPass.bindTexture("uSourceDepthTexture", this.sourceDepthTextureView, this.sourceDepthSampler); + renderPass.bindTexture("uSourceColorTexture", this.sourceColorTextureViewWrapper.textureView, this.sourceColorTextureViewWrapper.textureSampler); + renderPass.bindTexture("uSourceDepthTexture", this.sourceDepthTextureViewWrapper.textureView, this.sourceDepthTextureViewWrapper.textureSampler); renderPass.setVertexBuffer(0, this.vboGpuBuffer); renderPass.setPipeline(this.pipeline); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java index d70c06e05..d791a93ef 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java @@ -31,6 +31,8 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -49,10 +51,10 @@ import java.util.function.Supplier; */ public class McCopyRenderer { - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final McCopyRenderer INSTANCE = new McCopyRenderer(); @@ -154,66 +156,48 @@ public class McCopyRenderer //========// //region - public void render(GpuTexture sourceTexture, GpuTexture destinationTexture) + public void render( + McTextureWrapper sourceColorTextureWrapper, + McTextureViewWrapper destinationColorTextureWrapper) + { + this.render( + sourceColorTextureWrapper.textureView, sourceColorTextureWrapper.textureSampler, + destinationColorTextureWrapper.textureView); + } + public void render( + McTextureWrapper sourceColorTextureWrapper, + McTextureWrapper destinationColorTextureWrapper) + { + this.render( + sourceColorTextureWrapper.textureView, sourceColorTextureWrapper.textureSampler, + destinationColorTextureWrapper.textureView); + } + + private void render( + GpuTextureView sourceTextureView, + GpuSampler sourceTextureSampler, + GpuTextureView destinationTextureView) { this.tryInit(); - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - - // create a render pass + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + destinationTextureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - Supplier debugLabelSupplier = () -> "distantHorizons:McCopyRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(destinationTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); + renderPass.bindTexture("uCopyTexture", sourceTextureView, sourceTextureSampler); - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) - { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); - - - // render pass setup - { - // bind color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(sourceTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uCopyTexture", textureView, gpuSampler); - } - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } - - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + renderPass.setPipeline(this.pipeline); + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } + private String getName() { return "distantHorizons:McCopyRenderer"; } + //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java index 3c78a2bd8..e2703eef8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java @@ -5,6 +5,8 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; import java.nio.ByteBuffer; @@ -12,6 +14,9 @@ import java.nio.ByteOrder; public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrapper { + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private final String name; private ByteBuffer buffer = null; @@ -62,7 +67,14 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap int byteSize = (this.buffer.limit() - this.buffer.position()); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.gpuBuffer, /*offset*/0, byteSize); - commandEncoder.writeToBuffer(bufferSlice, this.buffer); + if (!bufferSlice.buffer().isClosed()) + { + commandEncoder.writeToBuffer(bufferSlice, this.buffer); + } + else + { + LOGGER.warn("Uploading to buffer ["+this.name+"] failed due to already being closed"); + } } private String getName() { return this.name; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java new file mode 100644 index 000000000..93e93b334 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java @@ -0,0 +1,59 @@ +package com.seibel.distanthorizons.common.renderTest.helpers; + +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; + +import java.util.OptionalDouble; + +public class McTextureViewWrapper +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + + + public GpuTextureView textureView = null; + public GpuSampler textureSampler = null; + + + + public void trySetup(GpuTexture texture) + { + this.tryRecreateTextureView(texture); + this.tryCreateSampler(); + } + private void tryRecreateTextureView(GpuTexture texture) + { + if (this.textureView == null + || this.textureView.texture() != texture) + { + if (this.textureView != null) + { + this.textureView.close(); + } + + this.textureView = GPU_DEVICE.createTextureView(texture); + } + } + private void tryCreateSampler() + { + if (this.textureSampler == null) + { + this.textureSampler = GPU_DEVICE.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java new file mode 100644 index 000000000..cc5338bfc --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java @@ -0,0 +1,113 @@ +package com.seibel.distanthorizons.common.renderTest.helpers; + +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.textures.*; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.ColorUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; + +import java.util.OptionalDouble; + +public class McTextureWrapper +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + + public final String name; + public final TextureFormat textureFormat; + + public GpuTexture texture = null; + public GpuTextureView textureView = null; + public GpuSampler textureSampler = null; + + + + public static McTextureWrapper createDepth(String name) { return new McTextureWrapper(name, TextureFormat.DEPTH32); } + public static McTextureWrapper createColor(String name) { return new McTextureWrapper(name, TextureFormat.RGBA8); } + + private McTextureWrapper(String name, TextureFormat textureFormat) + { + this.name = name; + this.textureFormat = textureFormat; + } + + + + public boolean isEmpty() { return this.texture == null; } + + public void trySetup() + { + this.tryCreateTexture(); + this.tryCreateSampler(); + } + private void tryCreateTexture() + { + int viewWidth = MC_RENDER.getTargetFramebufferViewportWidth(); + int textureWidth = (this.texture != null) ? this.texture.getWidth(0) : -1; + + int viewHeight = MC_RENDER.getTargetFramebufferViewportHeight(); + int textureHeight = (this.texture != null) ? this.texture.getHeight(0) : -1; + + if (this.texture == null + || textureWidth != viewWidth + || textureHeight != viewHeight) + { + if (this.texture != null) + { + this.texture.close(); + this.textureView.close(); + } + + // TODO USAGE_TEXTURE_BINDING = 4 + int usage = 4 | 8 | 32 | 128; + this.texture = GPU_DEVICE.createTexture(this.name, + usage, + this.textureFormat, + viewWidth, viewHeight, + /*depthOrLayers*/ 1, /*mipLevels*/ 1 + ); + this.textureView = GPU_DEVICE.createTextureView(this.texture); + } + } + private void tryCreateSampler() + { + if (this.textureSampler == null) + { + this.textureSampler = GPU_DEVICE.createSampler( + AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V + FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + 1, // maxAnisotropy + OptionalDouble.empty() // maxLod + ); + } + } + + + /** @see ColorUtil#argbToInt */ + public void clearColor(int clearArgbColor) + { + if (this.texture != null) + { + COMMAND_ENCODER.clearColorTexture(this.texture, clearArgbColor); + } + } + public void clearDepth(float depth) + { + if (this.texture != null) + { + COMMAND_ENCODER.clearDepthTexture(this.texture, depth); + } + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java index 2e0a85cbb..a99d313e0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java @@ -36,6 +36,8 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -64,6 +66,9 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + public static final McFarFadeRenderer INSTANCE = new McFarFadeRenderer(); private VertexFormat vertexFormat; @@ -74,7 +79,8 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private GpuBuffer vboGpuBuffer; - public GpuTexture fadeColorTexture; + public final McTextureWrapper dhFadeColorTextureWrapper = McTextureWrapper.createColor("DhFadeColorTexture"); + public final McTextureViewWrapper mcColorTextureViewWrapper = new McTextureViewWrapper(); @@ -180,38 +186,17 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTexture == null - || McLodRenderer.INSTANCE.dhColorTexture == null) + if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // textures - if (this.fadeColorTexture == null - || this.fadeColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.fadeColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) - { - if (this.fadeColorTexture != null) - { - this.fadeColorTexture.close(); - } - - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; - this.fadeColorTexture = gpuDevice.createTexture("FadeColorTexture", - usage, - TextureFormat.RGBA8, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - } - + this.dhFadeColorTextureWrapper.trySetup(); + this.mcColorTextureViewWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); { int uniformBufferSize = new Std140SizeCalculator() @@ -252,12 +237,12 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } this.renderFadeToTexture(); - McCopyRenderer.INSTANCE.render(this.fadeColorTexture, McLodRenderer.INSTANCE.dhColorTexture); + McCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, McLodRenderer.INSTANCE.dhColorTextureWrapper); } @@ -266,81 +251,29 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer GpuDevice gpuDevice = RenderSystem.getDevice(); CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McFadeRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(this.fadeColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + this::getName, + this.dhFadeColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); + // MC texture + renderPass.bindTexture("uMcColorTexture", this.mcColorTextureViewWrapper.textureView, this.mcColorTextureViewWrapper.textureSampler); + // DH textures + renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); - // render pass setup - { - // bind MC color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uMcColorTexture", textureView, gpuSampler); - } - - - // bind DH depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - // bind DH color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); - } - - - - renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + renderPass.setPipeline(this.pipeline); + + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } + private String getName() { return "distantHorizons:McFadeRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java index 5998f078f..e0e251937 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java @@ -43,6 +43,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -72,7 +73,9 @@ public class McFogRenderer implements IMcFogRenderer private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final McFogRenderer INSTANCE = new McFogRenderer(); @@ -87,7 +90,7 @@ public class McFogRenderer implements IMcFogRenderer private GpuBuffer vboGpuBuffer; - public GpuTexture fogColorTexture; + public McTextureWrapper fogColorTextureWrapper = McTextureWrapper.createColor("DhFogColorTexture"); @@ -139,9 +142,6 @@ public class McFogRenderer implements IMcFogRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/quad_apply")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/fog")); - pipelineBuilder.withSampler("uMcDepthTexture"); - pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); - pipelineBuilder.withSampler("uDhDepthTexture"); pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); @@ -201,37 +201,15 @@ public class McFogRenderer implements IMcFogRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTexture == null - || McLodRenderer.INSTANCE.dhColorTexture == null) + if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - // textures - if (this.fogColorTexture == null - || this.fogColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.fogColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) - { - if (this.fogColorTexture != null) - { - this.fogColorTexture.close(); - } - - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; - this.fogColorTexture = gpuDevice.createTexture("FogColorTexture", - usage, - TextureFormat.RGBA8, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - } + this.fogColorTextureWrapper.trySetup(); { @@ -372,12 +350,12 @@ public class McFogRenderer implements IMcFogRenderer this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } this.renderFogToTexture(); - this.applyRenderer.render(this.fogColorTexture, McLodRenderer.INSTANCE.dhDepthTexture, McLodRenderer.INSTANCE.dhColorTexture); + this.applyRenderer.render(this.fogColorTextureWrapper.texture, McLodRenderer.INSTANCE.dhDepthTextureWrapper.texture, McLodRenderer.INSTANCE.dhColorTextureWrapper.texture); } @@ -399,58 +377,24 @@ public class McFogRenderer implements IMcFogRenderer private void renderFogToTexture() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McFogRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(this.fogColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + this.fogColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); + renderPass.bindTexture("uDhDepthTexture", this.fogColorTextureWrapper.textureView, this.fogColorTextureWrapper.textureSampler); + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - // render pass setup - { - // bind DH depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - - renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + renderPass.setPipeline(this.pipeline); - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } + private String getName() { return "distantHorizons:McFogRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java index bea03b91e..25e9db043 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java @@ -40,6 +40,8 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -64,7 +66,9 @@ public class McSsaoRenderer implements IMcSsaoRenderer public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final McSsaoRenderer INSTANCE = new McSsaoRenderer(); @@ -79,7 +83,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private GpuBuffer vboGpuBuffer; - public GpuTexture ssaoColorTexture; + public McTextureWrapper ssaoColorTextureWrapper = McTextureWrapper.createColor("DhSsaoTexture"); @@ -128,9 +132,6 @@ public class McSsaoRenderer implements IMcSsaoRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/ao")); - pipelineBuilder.withSampler("uMcDepthTexture"); - pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); - pipelineBuilder.withSampler("uDhDepthTexture"); pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); @@ -190,38 +191,16 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTexture == null - || McLodRenderer.INSTANCE.dhColorTexture == null) + if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // textures - if (this.ssaoColorTexture == null - || this.ssaoColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.ssaoColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) - { - if (this.ssaoColorTexture != null) - { - this.ssaoColorTexture.close(); - } - - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; - this.ssaoColorTexture = gpuDevice.createTexture("SsaoColorTexture", - usage, - TextureFormat.RGBA8, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - } - + this.ssaoColorTextureWrapper.trySetup(); { int uniformBufferSize = new Std140SizeCalculator() @@ -266,69 +245,35 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } this.renderSsaoToTexture(); - this.applyRenderer.render(this.ssaoColorTexture, McLodRenderer.INSTANCE.dhDepthTexture, McLodRenderer.INSTANCE.dhColorTexture); + this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, McLodRenderer.INSTANCE.dhDepthTextureWrapper.texture, McLodRenderer.INSTANCE.dhColorTextureWrapper.texture); } private void renderSsaoToTexture() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McSsaoRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(this.ssaoColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + this.ssaoColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); + renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - // render pass setup - { - // bind DH depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - - renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } + renderPass.setPipeline(this.pipeline); + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } + private String getName() { return "distantHorizons:McSsaoRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java index 52f5fc9b5..ec91d7e08 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java @@ -36,6 +36,8 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -43,7 +45,6 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcVanillaFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; @@ -64,7 +65,9 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final McVanillaFadeRenderer INSTANCE = new McVanillaFadeRenderer(); @@ -76,7 +79,10 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer private GpuBuffer vboGpuBuffer; - public GpuTexture fadeColorTexture; + public final McTextureWrapper fadeColorTextureWrapper = McTextureWrapper.createColor("DhVanillaFadeTexture"); + + public final McTextureViewWrapper mcDepthTextureWrapper = new McTextureViewWrapper(); + public final McTextureViewWrapper mcColorTextureWrapper = new McTextureViewWrapper(); @@ -182,38 +188,18 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer { this.tryInit(); - - if (McLodRenderer.INSTANCE.dhDepthTexture == null - || McLodRenderer.INSTANCE.dhColorTexture == null) + if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - // textures - if (this.fadeColorTexture == null - || this.fadeColorTexture.getWidth(0) != MC_RENDER.getTargetFramebufferViewportWidth() - || this.fadeColorTexture.getHeight(0) != MC_RENDER.getTargetFramebufferViewportHeight()) - { - if (this.fadeColorTexture != null) - { - this.fadeColorTexture.close(); - } - - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; - this.fadeColorTexture = gpuDevice.createTexture("FadeColorTexture", - usage, - TextureFormat.RGBA8, - MC_RENDER.getTargetFramebufferViewportWidth(), MC_RENDER.getTargetFramebufferViewportHeight(), - 1, 1 - ); - } + this.fadeColorTextureWrapper.trySetup(); + + this.mcDepthTextureWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + this.mcColorTextureWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); { @@ -273,108 +259,39 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } this.renderFadeToTexture(); - McCopyRenderer.INSTANCE.render(this.fadeColorTexture, Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + McCopyRenderer.INSTANCE.render(this.fadeColorTextureWrapper, this.mcColorTextureWrapper); } private void renderFadeToTexture() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // create a render pass - Supplier debugLabelSupplier = () -> "distantHorizons:McFadeRenderer"; - GpuTextureView colorTexture = gpuDevice.createTextureView(this.fadeColorTexture); - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView depthTexture = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - debugLabelSupplier, - colorTexture, - optionalClearColorAsInt, - depthTexture, optionalDepthValueAsDouble)) + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getRenderPassName, + this.fadeColorTextureWrapper.textureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*depthTexture*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - //renderPass.pushDebugGroup(); - //renderPass.popDebugGroup(); + renderPass.bindTexture("uMcDepthTexture", this.mcDepthTextureWrapper.textureView, this.mcDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uCombinedMcDhColorTexture", this.mcColorTextureWrapper.textureView, this.mcColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); - // render pass setup - { - // bind MC depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uMcDepthTexture", textureView, gpuSampler); - } - - // bind MC color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uCombinedMcDhColorTexture", textureView, gpuSampler); - } - - - // bind DH depth texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhDepthTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhDepthTexture", textureView, gpuSampler); - } - - // bind DH color texture - { - GpuTextureView textureView = gpuDevice.createTextureView(McLodRenderer.INSTANCE.dhColorTexture); - GpuSampler gpuSampler = gpuDevice.createSampler( - AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter - 1, // maxAnisotropy - OptionalDouble.empty() // maxLod - ); - renderPass.bindTexture("uDhColorTexture", textureView, gpuSampler); - } - - - - renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - - // bind VBO - renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol - - // set pipeline - renderPass.setPipeline(this.pipeline); - } + renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); - // draw render pass - { - int indexStart = 0; - int indexCount = 4; - renderPass.draw(indexStart, indexCount); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); // vertex buffer can only be "0" lol + + renderPass.setPipeline(this.pipeline); + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } - + private String getRenderPassName() { return "distantHorizons:McFadeRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java index dde624fd3..988d5f16b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java @@ -50,7 +50,10 @@ import java.util.function.Supplier; */ public class DhTestRenderer implements IMcTestRenderer { - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); public static final DhTestRenderer INSTANCE = new DhTestRenderer(); @@ -80,10 +83,6 @@ public class DhTestRenderer implements IMcTestRenderer - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - VertexFormat vertexFormat = VertexFormat.builder() .add("vPosition", DhVertexFormat.SCREEN_POS) .add("vColor", DhVertexFormat.RGBA_FLOAT_COLOR) @@ -115,7 +114,7 @@ public class DhTestRenderer implements IMcTestRenderer this.pipeline = pipelineBuilder.build(); - this.mcColorTextureView = gpuDevice.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + this.mcColorTextureView = GPU_DEVICE.createTextureView(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); this.uploadVertexData(); @@ -170,31 +169,19 @@ public class DhTestRenderer implements IMcTestRenderer { this.tryInit(); - - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - - // create a render pass + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + this::getName, + this.mcColorTextureView, + /*optionalClearColorAsInt*/ OptionalInt.empty(), + /*mcDepthTextureView*/ null, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - OptionalInt optionalClearColorAsInt = OptionalInt.empty(); - GpuTextureView mcDepthTextureView = null; - OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( - () -> "distantHorizons:DhTestRenderer", - this.mcColorTextureView, - optionalClearColorAsInt, - mcDepthTextureView, optionalDepthValueAsDouble)) - { - renderPass.setVertexBuffer(0, this.vboGpuBuffer); - renderPass.setPipeline(this.pipeline); - renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 3); - } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); + renderPass.setPipeline(this.pipeline); + renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 3); } } + private String getName() { return "distantHorizons:DhTestRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 9d3f57f59..3835720e1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; +import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; @@ -39,7 +40,9 @@ public class LightMapWrapper implements ILightMapWrapper private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private int textureId = 0; - public GpuTexture gpuTexture = null; + + private GpuTexture gpuTexture = null; + private final McTextureViewWrapper lightmapTextureWrapper = new McTextureViewWrapper(); @@ -103,8 +106,8 @@ public class LightMapWrapper implements ILightMapWrapper public void setLightmapGpuTexture(GpuTexture gpuTexture) { - // just use the MC texture ID this.gpuTexture = gpuTexture; + this.lightmapTextureWrapper.trySetup(this.gpuTexture); } //endregion @@ -116,6 +119,8 @@ public class LightMapWrapper implements ILightMapWrapper //==============// //region + public McTextureViewWrapper getTextureViewWrapper() { return this.lightmapTextureWrapper; } + @Override public void bind() { From f745e9c51a58eebe1d75cb552c8ca517f45e5861 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sun, 8 Mar 2026 19:32:52 -0500 Subject: [PATCH 24/72] Merge post-processing VBO logic --- .../renderTest/McDebugObjectRenderer.java | 4 +- .../renderTest/McGenericObjectRenderer.java | 2 +- .../common/renderTest/McLodRenderer.java | 4 +- .../renderTest/apply/DhApplyRenderer.java | 40 ++------------ .../renderTest/apply/McCopyRenderer.java | 34 +----------- .../helpers/AbstractUniformBufferWrapper.java | 2 +- .../helpers/McInstancedVboContainer.java | 4 +- .../renderTest/helpers/PostProcessHelper.java | 55 +++++++++++++++++++ .../postProcessing/McFarFadeRenderer.java | 41 +------------- .../postProcessing/McFogRenderer.java | 37 +------------ .../postProcessing/McSsaoRenderer.java | 41 +------------- .../postProcessing/McVanillaFadeRenderer.java | 41 +------------- 12 files changed, 83 insertions(+), 222 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java index 17a562cee..1050db3fa 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java @@ -207,7 +207,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer // box vertex indexes { ByteBuffer buffer = ByteBuffer.allocateDirect(BOX_OUTLINE_INDICES.length * Integer.BYTES); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer.asIntBuffer().put(BOX_OUTLINE_INDICES); buffer.rewind(); @@ -305,7 +305,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putMat4f(transformMatrix.createJomlMatrix()) // uTransform .putVec4( diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java index db03e9489..cdfc5d6c5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java @@ -446,7 +446,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putIVec3( LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().x), diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java index a1366e526..34d51edab 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java @@ -211,7 +211,7 @@ public class McLodRenderer implements IMcLodRenderer .get(); ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); Std140Builder.intoBuffer(buffer) .putInt(0) // uIsWhiteWorld @@ -253,7 +253,7 @@ public class McLodRenderer implements IMcLodRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putFloat(dhNearClipDistance) // uClipDistance .putFloat(Config.Client.Advanced.Graphics.NoiseTexture.noiseIntensity.get()) // uNoiseIntensity diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java index 3d09de693..5b877080a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java @@ -34,6 +34,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import net.minecraft.resources.Identifier; @@ -59,6 +60,7 @@ public class DhApplyRenderer protected GpuBuffer vboGpuBuffer; + protected final String name; protected final String identifierName; public String getIdentifierName() { return this.identifierName; } @@ -85,7 +87,8 @@ public class DhApplyRenderer String vertexShaderPath, String fragmentShaderPath ) { - this.identifierName = "distanthorizons:"+name; + this.name = name; + this.identifierName = "distanthorizons:"+this.name; this.blendFunction = blendFunction; this.vertexShaderPath = vertexShaderPath; @@ -98,7 +101,7 @@ public class DhApplyRenderer GpuTexture destinationColorTexture) { this.createPipeline(); - this.uploadVertexData(); + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData(this.name); this.sourceColorTextureViewWrapper.trySetup(sourceColorTexture); this.sourceDepthTextureViewWrapper.trySetup(sourceDepthTexture); @@ -147,38 +150,7 @@ public class DhApplyRenderer } this.pipeline = pipelineBuilder.build(); } - private void uploadVertexData() - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:"+this.identifierName; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); - } - } + //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java index d791a93ef..bdc663459 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java @@ -33,6 +33,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -112,38 +113,7 @@ public class McCopyRenderer this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McCopyRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McCopyRenderer"); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java index e2703eef8..3f6b9e322 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java @@ -40,7 +40,7 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap || this.buffer.capacity() != size) { this.buffer = ByteBuffer.allocateDirect(size); - this.buffer.order(ByteOrder.LITTLE_ENDIAN); + this.buffer.order(ByteOrder.nativeOrder()); // GpuBuffer.USAGE_UNIFORM = 128 // GpuBuffer.USAGE_INDEX = 64 diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java index 58f147a6b..bc8b8036b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java @@ -197,11 +197,11 @@ public class McInstancedVboContainer implements IInstancedVboContainer int vertexBufferSize = this.vertexBufferSize(); this.vertexBuffer = ByteBuffer.allocateDirect(vertexBufferSize); - this.vertexBuffer.order(ByteOrder.LITTLE_ENDIAN); + this.vertexBuffer.order(ByteOrder.nativeOrder()); int indexBufferSize = this.indexBufferSize(); this.indexBuffer = ByteBuffer.allocateDirect(indexBufferSize); - this.indexBuffer.order(ByteOrder.LITTLE_ENDIAN); + this.indexBuffer.order(ByteOrder.nativeOrder()); } this.vertexBuffer.position(0); this.indexBuffer.position(0); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java new file mode 100644 index 000000000..c5b03d767 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java @@ -0,0 +1,55 @@ +package com.seibel.distanthorizons.common.renderTest.helpers; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.function.Supplier; + +public class PostProcessHelper +{ + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + // vertices for a full-screen quad + private static final float[] VERTICES = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + public static GpuBuffer createAndUploadScreenVertexData(String name) + { + + Supplier labelSupplier = () -> "distantHorizons:"+name; + // TODO + int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int size = VERTICES.length * Float.BYTES; + GpuBuffer vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); + + { + int length = VERTICES.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, /*offset*/ 0, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(VERTICES.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(VERTICES); + byteBuffer.rewind(); + + COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); + } + + return vboGpuBuffer; + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java index a99d313e0..70387a5ac 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java @@ -33,12 +33,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.*; import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -136,39 +133,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFadeRenderer"); } //endregion @@ -226,7 +191,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putFloat(fadeStartDistance) // uStartFadeBlockDistance .putFloat(fadeEndDistance) // uEndFadeBlockDistance diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java index e0e251937..9494c6a04 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java @@ -44,6 +44,7 @@ import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -151,39 +152,7 @@ public class McFogRenderer implements IMcFogRenderer this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McFogRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFogRenderer"); } //endregion @@ -302,7 +271,7 @@ public class McFogRenderer implements IMcFogRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) // fog uniforms diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java index 25e9db043..52065d2bb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java @@ -38,11 +38,8 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.renderTest.helpers.*; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -141,39 +138,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McSsao"); } //endregion @@ -227,7 +192,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putInt(6) // uSampleCount diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java index ec91d7e08..122c0e44d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java @@ -35,10 +35,7 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; +import com.seibel.distanthorizons.common.renderTest.helpers.*; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -139,39 +136,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer this.pipeline = pipelineBuilder.build(); - // upload vertex data - { - // vertices for a full-screen quad - float[] vertices = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - Supplier labelSupplier = () -> "distantHorizons:McFadeRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); - - { - int offset = 0; - int length = vertices.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, offset, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(vertices.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(vertices); - byteBuffer.rewind(); - - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); - } - } - + this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFadeRenderer"); } //endregion @@ -245,7 +210,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer // upload data // ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); - buffer.order(ByteOrder.LITTLE_ENDIAN); + buffer.order(ByteOrder.nativeOrder()); buffer = Std140Builder.intoBuffer(buffer) .putInt(Config.Client.Advanced.Debugging.lodOnlyMode.get() ? 1 : 0) // uOnlyRenderLods .putFloat(fadeStartDistance) // uStartFadeBlockDistance From 19057218d616ddbd6950dde527d2769355eba946 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Sun, 8 Mar 2026 21:16:55 -0500 Subject: [PATCH 25/72] Fix ssao application --- .../renderTest/apply/DhApplyRenderer.java | 72 ++++++++++++++++++- .../helpers/McTextureViewWrapper.java | 2 +- .../renderTest/helpers/McTextureWrapper.java | 2 +- .../postProcessing/McSsaoRenderer.java | 45 +++++++++++- coreSubProjects | 2 +- 5 files changed, 118 insertions(+), 5 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java index 5b877080a..e66701dd2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java @@ -25,6 +25,7 @@ import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; import com.mojang.blaze3d.platform.PolygonMode; +import com.mojang.blaze3d.shaders.UniformType; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; @@ -37,11 +38,13 @@ import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.coreapi.ModInfo; import net.minecraft.resources.Identifier; import org.jetbrains.annotations.Nullable; import java.nio.ByteBuffer; import java.nio.ByteOrder; +import java.util.Arrays; import java.util.OptionalDouble; import java.util.OptionalInt; import java.util.function.Supplier; @@ -74,18 +77,41 @@ public class DhApplyRenderer private final McTextureViewWrapper destinationColorTextureViewWrapper = new McTextureViewWrapper(); + /** + * Can be set for special application shaders that need + * extra information.

+ * + * will be an empty array if unneeded + */ + private final String[] uniformNames; + /** will be an empty array if unneeded */ + private final GpuBuffer[] uniformBuffers; + //=============// // constructor // //=============// //region - public DhApplyRenderer( String name, @Nullable BlendFunction blendFunction, String vertexShaderPath, String fragmentShaderPath ) + { + this( + name, + blendFunction, + vertexShaderPath, fragmentShaderPath, + new String[0] // no extra uniforms + ); + } + public DhApplyRenderer( + String name, + @Nullable BlendFunction blendFunction, + String vertexShaderPath, String fragmentShaderPath, + String[] uniformNames + ) { this.name = name; this.identifierName = "distanthorizons:"+this.name; @@ -93,6 +119,9 @@ public class DhApplyRenderer this.vertexShaderPath = vertexShaderPath; this.fragmentShaderPath = fragmentShaderPath; + + this.uniformNames = uniformNames; + this.uniformBuffers = new GpuBuffer[this.uniformNames.length]; } private void tryInit( @@ -143,6 +172,12 @@ public class DhApplyRenderer pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", this.vertexShaderPath)); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", this.fragmentShaderPath)); + for (int i = 0; i < this.uniformNames.length; i++) + { + String uniformName = this.uniformNames[i]; + pipelineBuilder.withUniform(uniformName, UniformType.UNIFORM_BUFFER); + } + pipelineBuilder.withSampler("uSourceColorTexture"); pipelineBuilder.withSampler("uSourceDepthTexture"); @@ -161,6 +196,21 @@ public class DhApplyRenderer //========// //region + public void setUniform(String uniformName, GpuBuffer uniformBuffer) + { + // the uniform array should be short enough (less than 10 items) + // where a sequential search should be plenty fast + for (int i = 0; i < this.uniformNames.length; i++) + { + String nameAtIndex = this.uniformNames[i]; + if (nameAtIndex.equals(uniformName)) + { + this.uniformBuffers[i] = uniformBuffer; + break; + } + } + } + public void render( GpuTexture sourceColorTexture, GpuTexture sourceDepthTexture, @@ -178,11 +228,31 @@ public class DhApplyRenderer renderPass.bindTexture("uSourceColorTexture", this.sourceColorTextureViewWrapper.textureView, this.sourceColorTextureViewWrapper.textureSampler); renderPass.bindTexture("uSourceDepthTexture", this.sourceDepthTextureViewWrapper.textureView, this.sourceDepthTextureViewWrapper.textureSampler); + for (int i = 0; i < this.uniformNames.length; i++) + { + String uniformName = this.uniformNames[i]; + GpuBuffer uniformBuffer = this.uniformBuffers[i]; + if (uniformBuffer == null) + { + throw new IllegalStateException("Missing uniform ["+uniformName+"], please set the uniform before rendering."); + } + + renderPass.setUniform(uniformName, uniformBuffer); + } + renderPass.setVertexBuffer(0, this.vboGpuBuffer); renderPass.setPipeline(this.pipeline); renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } + + + // clear the uniforms after rendering + // so we can check if they're missing during next frame's rendering + if (ModInfo.IS_DEV_BUILD) + { + Arrays.fill(this.uniformBuffers, null); + } } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java index 93e93b334..5e6cc87c5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java @@ -47,7 +47,7 @@ public class McTextureViewWrapper { this.textureSampler = GPU_DEVICE.createSampler( AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + FilterMode.LINEAR, FilterMode.LINEAR, // minFilter, magFilter 1, // maxAnisotropy OptionalDouble.empty() // maxLod ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java index cc5338bfc..8aba4aacf 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java @@ -84,7 +84,7 @@ public class McTextureWrapper { this.textureSampler = GPU_DEVICE.createSampler( AddressMode.CLAMP_TO_EDGE, AddressMode.CLAMP_TO_EDGE, // U,V - FilterMode.NEAREST, FilterMode.NEAREST, // minFilter, magFilter + FilterMode.LINEAR, FilterMode.LINEAR, // minFilter, magFilter 1, // maxAnisotropy OptionalDouble.empty() // maxLod ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java index 52065d2bb..cb66847f2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java @@ -43,6 +43,7 @@ import com.seibel.distanthorizons.common.renderTest.McLodRenderer; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -77,6 +78,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private boolean init = false; private GpuBuffer fragUniformBuffer; + private GpuBuffer applyFragUniformBuffer; private GpuBuffer vboGpuBuffer; @@ -108,7 +110,8 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.applyRenderer = new DhApplyRenderer( "ssao_apply_to_dh", new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE), - "apply/vert", "ssao/apply" + "apply/vert", "ssao/apply", + /*uniforms*/ new String[] { "applyFragUniformBlock" } ); GpuDevice gpuDevice = RenderSystem.getDevice(); @@ -167,6 +170,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer // textures this.ssaoColorTextureWrapper.trySetup(); + // frag uniforms { int uniformBufferSize = new Std140SizeCalculator() .putInt() // uSampleCount\ @@ -213,8 +217,47 @@ public class McSsaoRenderer implements IMcSsaoRenderer COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } + // apply frag uniforms + { + int uniformBufferSize = new Std140SizeCalculator() + .putVec2() // uViewSize + .putInt() // uBlurRadius + .putFloat() // uNearClipPlane + .putFloat() // uFarClipPlane + .get(); + + + // create data // + + float viewWidth = (float)MC_RENDER.getTargetFramebufferViewportWidth(); + float viewHeight = (float)MC_RENDER.getTargetFramebufferViewportHeight(); + + float nearClipPlane = RenderUtil.getNearClipPlaneInBlocks(); + float farClipPlane = RenderUtil.getFarClipPlaneDistanceInBlocks(); + + + // upload data // + + ByteBuffer buffer = ByteBuffer.allocateDirect(uniformBufferSize); + buffer.order(ByteOrder.nativeOrder()); + buffer = Std140Builder.intoBuffer(buffer) + .putVec2(viewWidth, viewHeight) // uViewSize + .putInt(2) // uBlurRadius + .putFloat(nearClipPlane) // uNearClipPlane + .putFloat(farClipPlane) // uFarClipPlane + .get() + ; + + this.applyFragUniformBuffer = UniformHandler.createBuffer("applyFragUniformBlock", uniformBufferSize, this.applyFragUniformBuffer); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.applyFragUniformBuffer, 0, uniformBufferSize); + + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); + } + this.renderSsaoToTexture(); + + this.applyRenderer.setUniform("applyFragUniformBlock", this.applyFragUniformBuffer); this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, McLodRenderer.INSTANCE.dhDepthTextureWrapper.texture, McLodRenderer.INSTANCE.dhColorTextureWrapper.texture); } diff --git a/coreSubProjects b/coreSubProjects index e790bfb7e..a5a9a62e8 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit e790bfb7e8ed309a0f1a490b4fd4a74e05db5ca7 +Subproject commit a5a9a62e8926be4c18049c0774c9796a31fb2d0f From f8eb1e8a97de6faeaf05847f8967cae9f076122f Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 08:27:24 -0500 Subject: [PATCH 26/72] Move blaze render namespace --- .../blaze}/McDebugObjectRenderer.java | 7 +++---- .../blaze}/McGenericObjectRenderer.java | 13 +++++-------- .../blaze}/McLodRenderer.java | 7 +++---- .../blaze}/apply/DhApplyRenderer.java | 9 ++++----- .../blaze}/apply/McCopyRenderer.java | 17 +++++------------ .../helpers/AbstractUniformBufferWrapper.java | 2 +- .../blaze}/helpers/DhVertexFormat.java | 2 +- .../LodContainerUniformBufferWrapper.java | 2 +- .../blaze}/helpers/McInstancedVboContainer.java | 2 +- .../blaze}/helpers/McTextureViewWrapper.java | 2 +- .../blaze}/helpers/McTextureWrapper.java | 2 +- .../blaze}/helpers/PostProcessHelper.java | 2 +- .../blaze}/helpers/UniformHandler.java | 2 +- .../blaze}/helpers/VertexBufferWrapper.java | 2 +- .../postProcessing/McFarFadeRenderer.java | 10 ++++------ .../blaze}/postProcessing/McFogRenderer.java | 17 +++++++---------- .../blaze}/postProcessing/McSsaoRenderer.java | 14 +++++++------- .../postProcessing/McVanillaFadeRenderer.java | 10 ++++------ .../blaze}/test/DhTestRenderer.java | 4 ++-- .../common/wrappers/DependencySetup.java | 13 +++++++------ .../common/wrappers/WrapperFactory.java | 8 ++++---- .../common/wrappers/misc/LightMapWrapper.java | 2 +- 22 files changed, 65 insertions(+), 84 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/McDebugObjectRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/McGenericObjectRenderer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/McLodRenderer.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/apply/DhApplyRenderer.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/apply/McCopyRenderer.java (86%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/AbstractUniformBufferWrapper.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/DhVertexFormat.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/LodContainerUniformBufferWrapper.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/McInstancedVboContainer.java (99%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/McTextureViewWrapper.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/McTextureWrapper.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/PostProcessHelper.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/UniformHandler.java (92%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/helpers/VertexBufferWrapper.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/postProcessing/McFarFadeRenderer.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/postProcessing/McFogRenderer.java (94%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/postProcessing/McSsaoRenderer.java (94%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/postProcessing/McVanillaFadeRenderer.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/{renderTest => render/blaze}/test/DhTestRenderer.java (97%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java index 1050db3fa..0fc2019a3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.render.blaze; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -31,10 +31,9 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.GpuTextureView; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index cdfc5d6c5..9e1ce1dea 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.render.blaze; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -32,7 +32,6 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; @@ -43,10 +42,10 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeG import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.McInstancedVboContainer; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -59,7 +58,6 @@ import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGrou import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; @@ -75,7 +73,6 @@ import java.util.Collection; import java.util.OptionalDouble; import java.util.OptionalInt; import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Supplier; /** * Handles rendering generic groups of {@link DhApiRenderableBox}. diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 34d51edab..050bca36b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest; +package com.seibel.distanthorizons.common.render.blaze; import com.mojang.blaze3d.buffers.GpuBuffer; @@ -16,8 +16,8 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; @@ -45,7 +45,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders a TODO diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index e66701dd2..c6cb0d436 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.apply; +package com.seibel.distanthorizons.common.render.blaze.apply; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -32,10 +32,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.coreapi.ModInfo; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java similarity index 86% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index bdc663459..433c11b30 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -17,10 +17,9 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.apply; +package com.seibel.distanthorizons.common.render.blaze.apply; import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; import com.mojang.blaze3d.platform.PolygonMode; @@ -30,22 +29,16 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import net.minecraft.resources.Identifier; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * TODO ??? diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java index 3f6b9e322..e561b70e8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java index a687124b3..5cd213582 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.vertex.VertexFormatElement; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java index faa19377f..647162a76 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/LodContainerUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java similarity index 99% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java index bc8b8036b..d6e204c93 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McInstancedVboContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java index 5e6cc87c5..9686708ff 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java index 8aba4aacf..bb508adee 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/McTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java index c5b03d767..e30276f28 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/PostProcessHelper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java similarity index 92% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java index ebc4295bb..ead28ddcb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java index 44552b0c3..a180419ca 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/helpers/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.renderTest.helpers; +package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index 70387a5ac..a05cac1b6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.postProcessing; +package com.seibel.distanthorizons.common.render.blaze.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -31,11 +31,10 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.*; -import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -51,7 +50,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders a TODO diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java similarity index 94% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 9494c6a04..81e762ec8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.postProcessing; +package com.seibel.distanthorizons.common.render.blaze.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -34,18 +34,17 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.renderTest.helpers.PostProcessHelper; -import com.seibel.distanthorizons.common.renderTest.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -53,7 +52,6 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFogRenderer; import net.minecraft.resources.Identifier; @@ -63,7 +61,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders a TODO diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java similarity index 94% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index cb66847f2..2bac3f00a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.postProcessing; +package com.seibel.distanthorizons.common.render.blaze.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -34,18 +34,19 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.renderTest.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.*; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; import net.minecraft.resources.Identifier; @@ -54,7 +55,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders a TODO diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 122c0e44d..f45e4e38d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.postProcessing; +package com.seibel.distanthorizons.common.render.blaze.postProcessing; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -31,11 +31,10 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.McLodRenderer; -import com.seibel.distanthorizons.common.renderTest.apply.McCopyRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -52,7 +51,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders a TODO diff --git a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index 988d5f16b..79942a9da 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/renderTest/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.renderTest.test; +package com.seibel.distanthorizons.common.render.blaze.test; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -30,7 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.renderTest.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index d3d9b3827..cffbce4ec 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,12 +19,13 @@ package com.seibel.distanthorizons.common.wrappers; -import com.seibel.distanthorizons.common.renderTest.*; -import com.seibel.distanthorizons.common.renderTest.postProcessing.McFarFadeRenderer; -import com.seibel.distanthorizons.common.renderTest.postProcessing.McFogRenderer; -import com.seibel.distanthorizons.common.renderTest.postProcessing.McSsaoRenderer; -import com.seibel.distanthorizons.common.renderTest.postProcessing.McVanillaFadeRenderer; -import com.seibel.distanthorizons.common.renderTest.test.DhTestRenderer; +import com.seibel.distanthorizons.common.render.blaze.McDebugObjectRenderer; +import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFarFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFogRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.McSsaoRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.McVanillaFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.test.DhTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 798e4c559..5344336c4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,10 +24,10 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; -import com.seibel.distanthorizons.common.renderTest.helpers.LodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.common.renderTest.McGenericObjectRenderer; -import com.seibel.distanthorizons.common.renderTest.helpers.McInstancedVboContainer; -import com.seibel.distanthorizons.common.renderTest.helpers.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; +import com.seibel.distanthorizons.common.render.blaze.helpers.LodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.render.blaze.helpers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 3835720e1..bd6978e13 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; -import com.seibel.distanthorizons.common.renderTest.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; From 3498faed5938112546e9c36fd491fecfb4a5cb48 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 09:18:59 -0500 Subject: [PATCH 27/72] 1.21.11 update neoforge 0 -> 38 --- versionProperties/1.21.11.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/versionProperties/1.21.11.properties b/versionProperties/1.21.11.properties index 92a14048f..24be330c0 100644 --- a/versionProperties/1.21.11.properties +++ b/versionProperties/1.21.11.properties @@ -45,7 +45,7 @@ fabric_api_version=0.139.4+1.21.11 # NeoForge loader forge_version= -neoforge_version=21.11.0-beta +neoforge_version=21.11.38-beta neoforge_version_range=[*,) # NeoForge mod versions From 354b6567d4724ecbcac6cc35b1fa643265b67c28 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 09:19:08 -0500 Subject: [PATCH 28/72] don't render closed VBOs --- .../common/render/blaze/McLodRenderer.java | 13 ++++++++----- .../common/render/blaze/helpers/UniformHandler.java | 1 + 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 050bca36b..dcf096a61 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -379,11 +379,14 @@ public class McLodRenderer implements IMcLodRenderer renderPass.setVertexBuffer(0, bufferWrapper.vboGpuBuffer); // vertex buffer can only be "0" lol - renderPass.drawIndexed( - /*indexStart*/ 0, - /*firstIndex*/0, - /*indexCount*/bufferWrapper.indexCount, - /*instanceCount*/1); + if (!bufferWrapper.vboGpuBuffer.isClosed()) + { + renderPass.drawIndexed( + /*indexStart*/ 0, + /*firstIndex*/0, + /*indexCount*/bufferWrapper.indexCount, + /*instanceCount*/1); + } } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java index ead28ddcb..c24e89065 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java @@ -16,6 +16,7 @@ public class UniformHandler if (vboGpuBuffer == null || vboGpuBuffer.size() < size) { + // TODO // GpuBuffer.USAGE_UNIFORM = 128 int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, size); From 84d1298e1808a15dd8f2b2bd739d719fa43e3302 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 09:57:43 -0500 Subject: [PATCH 29/72] move blaze shader files --- .../common/render/blaze/McDebugObjectRenderer.java | 4 ++-- .../common/render/blaze/McGenericObjectRenderer.java | 4 ++-- .../distanthorizons/common/render/blaze/McLodRenderer.java | 6 +++--- .../common/render/blaze/apply/McCopyRenderer.java | 4 ++-- .../render/blaze/postProcessing/McFarFadeRenderer.java | 4 ++-- .../common/render/blaze/postProcessing/McFogRenderer.java | 6 +++--- .../common/render/blaze/postProcessing/McSsaoRenderer.java | 6 +++--- .../render/blaze/postProcessing/McVanillaFadeRenderer.java | 4 ++-- .../common/render/blaze/test/DhTestRenderer.java | 4 ++-- coreSubProjects | 2 +- 10 files changed, 22 insertions(+), 22 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java index 0fc2019a3..2967fe271 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java @@ -159,8 +159,8 @@ public class McDebugObjectRenderer implements IMcDebugRenderer pipelineBuilder.withPolygonMode(PolygonMode.WIREFRAME); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:debug_renderer")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/blaze/frag")); pipelineBuilder.withUniform("uniformBlock", UniformType.UNIFORM_BUFFER); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 9e1ce1dea..748102a0d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -151,8 +151,8 @@ public class McGenericObjectRenderer implements IMcGenericRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:generic")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "generic/blaze/frag")); pipelineBuilder.withSampler("uLightMap"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index dcf096a61..0993b4ec8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -108,7 +108,7 @@ public class McLodRenderer implements IMcLodRenderer this.applyRenderer = new DhApplyRenderer( "dh_apply_to_mc", null, - "apply/vert", "apply/frag" + "apply/blaze/vert", "apply/blaze/frag" ); @@ -121,8 +121,8 @@ public class McLodRenderer implements IMcLodRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:lod_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "lod/blaze/frag")); pipelineBuilder.withSampler("uLightMap"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 433c11b30..b53364e30 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -96,8 +96,8 @@ public class McCopyRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:copy_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "copy/blaze/frag")); pipelineBuilder.withSampler("uCopyTexture"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index a05cac1b6..1e61939e0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -116,8 +116,8 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:far_fade")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/dh_fade")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/blaze/dh_fade")); pipelineBuilder.withSampler("uMcColorTexture"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 81e762ec8..428bde0c7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -118,7 +118,7 @@ public class McFogRenderer implements IMcFogRenderer this.applyRenderer = new DhApplyRenderer( "fog_apply_to_dh", new BlendFunction(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA), - "apply/vert", "apply/frag" + "apply/blaze/vert", "apply/blaze/frag" ); @@ -137,8 +137,8 @@ public class McFogRenderer implements IMcFogRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:fog_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/quad_apply")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/fog")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fog/blaze/frag")); pipelineBuilder.withSampler("uDhDepthTexture"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 2bac3f00a..aed362df7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -110,7 +110,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.applyRenderer = new DhApplyRenderer( "ssao_apply_to_dh", new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE), - "apply/vert", "ssao/apply", + "apply/blaze/vert", "ssao/blaze/apply", /*uniforms*/ new String[] { "applyFragUniformBlock" } ); @@ -129,8 +129,8 @@ public class McSsaoRenderer implements IMcSsaoRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:ssao_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/quad_apply")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/ao")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "ssao/blaze/frag")); pipelineBuilder.withSampler("uDhDepthTexture"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index f45e4e38d..08aca0595 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -118,8 +118,8 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:mc_vanilla_fade_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/vanilla_fade")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "fade/blaze/vanilla_fade")); pipelineBuilder.withSampler("uMcDepthTexture"); pipelineBuilder.withSampler("uCombinedMcDhColorTexture"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index 79942a9da..d15016f8d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -106,8 +106,8 @@ public class DhTestRenderer implements IMcTestRenderer pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:test_render")); - pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/vert")); - pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/frag")); + pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/blaze/vert")); + pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "test/blaze/frag")); pipelineBuilder.withVertexFormat(vertexFormat, VertexFormat.Mode.TRIANGLES); } diff --git a/coreSubProjects b/coreSubProjects index a5a9a62e8..bd833ba51 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit a5a9a62e8926be4c18049c0774c9796a31fb2d0f +Subproject commit bd833ba5106e2b1963e64c249b6e606e596d4367 From 3c680b5daf33e1121b2b7a31f9cfcd4743a87a76 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:24:09 -0500 Subject: [PATCH 30/72] rename vbo containers --- .../render/blaze/McGenericObjectRenderer.java | 5 +- .../helpers/McInstancedVboContainer.java | 8 ++-- .../blaze/helpers/VertexBufferWrapper.java | 47 +++++++++++++------ .../common/wrappers/WrapperFactory.java | 7 +-- coreSubProjects | 2 +- 5 files changed, 44 insertions(+), 25 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 748102a0d..35176e0b0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -53,7 +53,8 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; -import com.seibel.distanthorizons.core.render.renderer.generic.InstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.NativeGlGenericObjectVertexContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -397,7 +398,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer boxGroup.tryUpdateInstancedDataAsync(); // skip groups that haven't been uploaded yet - if (boxGroup.instancedVbos.getState() != InstancedVboContainer.EState.RENDER) + if (boxGroup.instancedVbos.getState() != IGenericObjectVertexBufferContainer.EState.RENDER) { continue; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java index d6e204c93..c479f632f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java @@ -11,7 +11,7 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.glObject.GLEnums; import com.seibel.distanthorizons.core.render.glObject.GLProxy; -import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; @@ -28,7 +28,7 @@ import java.util.function.Supplier; * * @see RenderableBoxGroup */ -public class McInstancedVboContainer implements IInstancedVboContainer +public class McInstancedVboContainer implements IGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -170,9 +170,9 @@ public class McInstancedVboContainer implements IInstancedVboContainer private EState state = EState.NEW; @Override - public IInstancedVboContainer.EState getState() { return this.state; } + public IGenericObjectVertexBufferContainer.EState getState() { return this.state; } @Override - public void setState(IInstancedVboContainer.EState state) { this.state = state; } + public void setState(IGenericObjectVertexBufferContainer.EState state) { this.state = state; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java index a180419ca..0972e4b58 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java @@ -12,6 +12,12 @@ import java.util.function.Supplier; public class VertexBufferWrapper implements IVertexBufferWrapper { + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + + public final String name; + public String getName() { return this.name; } public GpuBuffer vboGpuBuffer = null; public int vertexCount = -1; @@ -19,13 +25,20 @@ public class VertexBufferWrapper implements IVertexBufferWrapper public boolean uploaded = false; - @Override - public int getVertexCount() { return this.vertexCount ;} + + //=============// + // constructor // + //=============// + //region + + public VertexBufferWrapper(String name) { this.name = name; } + + //endregion //========// - // render // + // upload // //========// //region @@ -37,20 +50,24 @@ public class VertexBufferWrapper implements IVertexBufferWrapper this.uploaded = true; - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - Supplier labelSupplier = () -> "distantHorizons:McLodRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; int byteSize = (buffer.limit() - buffer.position()); - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, byteSize); + this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, byteSize); - { - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, byteSize); - commandEncoder.writeToBuffer(bufferSlice, buffer); - } + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, byteSize); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } + //endregion + + + + //================// + // base overrides // + //================// + //region + @Override public void close() { @@ -60,8 +77,8 @@ public class VertexBufferWrapper implements IVertexBufferWrapper } } - - //endregion + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 5344336c4..ca36bce37 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -36,7 +36,8 @@ import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; -import com.seibel.distanthorizons.core.render.renderer.generic.IInstancedVboContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; @@ -363,12 +364,12 @@ public class WrapperFactory implements IWrapperFactory @Override - public IVertexBufferWrapper createVboWrapper() { return new VertexBufferWrapper(); } + public IVertexBufferWrapper createVboWrapper(String name) { return new VertexBufferWrapper(name); } @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodContainerUniformBufferWrapper(); } @Override - public IInstancedVboContainer createInstancedVboContainer() { return new McInstancedVboContainer(); } + public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new McInstancedVboContainer(); } @Override public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } diff --git a/coreSubProjects b/coreSubProjects index bd833ba51..a8c15d22c 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit bd833ba5106e2b1963e64c249b6e606e596d4367 +Subproject commit a8c15d22c34df7fe12ada0eb8853867bc7aaa5f8 From c86c32b39e1b78bfea299d824c0a331588b4ccae Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:28:52 -0500 Subject: [PATCH 31/72] Rename texture wrappers --- ....java => BlazeDebugWireframeRenderer.java} | 10 +++++----- .../render/blaze/McGenericObjectRenderer.java | 17 ++++++++-------- .../common/render/blaze/McLodRenderer.java | 20 +++++++++---------- .../render/blaze/apply/DhApplyRenderer.java | 20 ++++++++----------- .../render/blaze/apply/McCopyRenderer.java | 20 +++++++++---------- ...=> BlazeGenericObjectVertexContainer.java} | 4 ++-- ...sHelper.java => BlazePostProcessUtil.java} | 2 +- ...pper.java => BlazeTextureViewWrapper.java} | 2 +- ...eWrapper.java => BlazeTextureWrapper.java} | 8 ++++---- ...exFormat.java => DhBlazeVertexFormat.java} | 2 +- .../postProcessing/McFarFadeRenderer.java | 8 ++++---- .../blaze/postProcessing/McFogRenderer.java | 12 +++++------ .../blaze/postProcessing/McSsaoRenderer.java | 12 +++++------ .../postProcessing/McVanillaFadeRenderer.java | 10 +++++----- .../render/blaze/test/DhTestRenderer.java | 6 +++--- .../common/wrappers/DependencySetup.java | 4 ++-- .../common/wrappers/WrapperFactory.java | 5 ++--- .../common/wrappers/misc/LightMapWrapper.java | 6 +++--- 18 files changed, 81 insertions(+), 87 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{McDebugObjectRenderer.java => BlazeDebugWireframeRenderer.java} (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/{McInstancedVboContainer.java => BlazeGenericObjectVertexContainer.java} (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/{PostProcessHelper.java => BlazePostProcessUtil.java} (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/{McTextureViewWrapper.java => BlazeTextureViewWrapper.java} (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/{McTextureWrapper.java => BlazeTextureWrapper.java} (89%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/{DhVertexFormat.java => DhBlazeVertexFormat.java} (98%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 2967fe271..be7c9a761 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McDebugObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -32,7 +32,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -57,7 +57,7 @@ import java.util.function.Supplier; /** * TODO */ -public class McDebugObjectRenderer implements IMcDebugRenderer +public class BlazeDebugWireframeRenderer implements IMcDebugRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -66,7 +66,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static McDebugObjectRenderer INSTANCE = new McDebugObjectRenderer(); + public static BlazeDebugWireframeRenderer INSTANCE = new BlazeDebugWireframeRenderer(); @@ -125,7 +125,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer //=============// //region - public McDebugObjectRenderer() { } + public BlazeDebugWireframeRenderer() { } public void init() { @@ -136,7 +136,7 @@ public class McDebugObjectRenderer implements IMcDebugRenderer this.init = true; this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) + .add("vPosition", DhBlazeVertexFormat.FLOAT_XYZ_POS) .build(); this.createPipelines(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 35176e0b0..338bbbb20 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -42,9 +42,9 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeG import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.McInstancedVboContainer; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -54,7 +54,6 @@ import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.NativeGlGenericObjectVertexContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -129,9 +128,9 @@ public class McGenericObjectRenderer implements IMcGenericRenderer this.init = true; this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.FLOAT_XYZ_POS) - .add("aColor", DhVertexFormat.RGBA_UBYTE_COLOR) - .add("aMaterial", DhVertexFormat.IRIS_MATERIAL) + .add("vPosition", DhBlazeVertexFormat.FLOAT_XYZ_POS) + .add("aColor", DhBlazeVertexFormat.RGBA_UBYTE_COLOR) + .add("aMaterial", DhBlazeVertexFormat.IRIS_MATERIAL) .build(); this.createPipelines(); @@ -549,10 +548,10 @@ public class McGenericObjectRenderer implements IMcGenericRenderer profiler.push("vertex setup"); - McInstancedVboContainer container = (McInstancedVboContainer) boxGroup.instancedVbos; + BlazeGenericObjectVertexContainer container = (BlazeGenericObjectVertexContainer) boxGroup.instancedVbos; LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); + BlazeTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 0993b4ec8..9373cd892 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -73,8 +73,8 @@ public class McLodRenderer implements IMcLodRenderer private GpuBuffer fragUniformBuffer; private GpuBuffer vertSharedUniformBuffer; - public final McTextureWrapper dhDepthTextureWrapper = McTextureWrapper.createDepth("DhDepthTexture"); - public final McTextureWrapper dhColorTextureWrapper = McTextureWrapper.createColor("DhColorTexture"); + public final BlazeTextureWrapper dhDepthTextureWrapper = BlazeTextureWrapper.createDepth("DhDepthTexture"); + public final BlazeTextureWrapper dhColorTextureWrapper = BlazeTextureWrapper.createColor("DhColorTexture"); @@ -86,13 +86,13 @@ public class McLodRenderer implements IMcLodRenderer private McLodRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SHORT_XYZ_POS) - .add("meta", DhVertexFormat.META) - .add("vColor", DhVertexFormat.RGBA_UBYTE_COLOR) - .add("irisMaterial", DhVertexFormat.IRIS_MATERIAL) - .add("irisNormal", DhVertexFormat.IRIS_NORMAL) - .add("paddingTwo", DhVertexFormat.BYTE_PAD) - .add("paddingThree", DhVertexFormat.BYTE_PAD) // padding is to make sure the format is a multiple of 4 + .add("vPosition", DhBlazeVertexFormat.SHORT_XYZ_POS) + .add("meta", DhBlazeVertexFormat.META) + .add("vColor", DhBlazeVertexFormat.RGBA_UBYTE_COLOR) + .add("irisMaterial", DhBlazeVertexFormat.IRIS_MATERIAL) + .add("irisNormal", DhBlazeVertexFormat.IRIS_NORMAL) + .add("paddingTwo", DhBlazeVertexFormat.BYTE_PAD) + .add("paddingThree", DhBlazeVertexFormat.BYTE_PAD) // padding is to make sure the format is a multiple of 4 .build(); } @@ -323,7 +323,7 @@ public class McLodRenderer implements IMcLodRenderer // bind MC Lightmap //renderPass.bindTexture("uLightMap", this.mcLightTextureViewWrapper.textureView, this.mcLightTextureViewWrapper.textureSampler); LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); + BlazeTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); // set pipeline diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index c6cb0d436..64b1a5774 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -20,7 +20,6 @@ package com.seibel.distanthorizons.common.render.blaze.apply; import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; @@ -32,21 +31,18 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.coreapi.ModInfo; import net.minecraft.resources.Identifier; import org.jetbrains.annotations.Nullable; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; import java.util.Arrays; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * TODO ??? @@ -71,10 +67,10 @@ public class DhApplyRenderer private final String vertexShaderPath; private final String fragmentShaderPath; - private final McTextureViewWrapper sourceColorTextureViewWrapper = new McTextureViewWrapper(); - private final McTextureViewWrapper sourceDepthTextureViewWrapper = new McTextureViewWrapper(); + private final BlazeTextureViewWrapper sourceColorTextureViewWrapper = new BlazeTextureViewWrapper(); + private final BlazeTextureViewWrapper sourceDepthTextureViewWrapper = new BlazeTextureViewWrapper(); - private final McTextureViewWrapper destinationColorTextureViewWrapper = new McTextureViewWrapper(); + private final BlazeTextureViewWrapper destinationColorTextureViewWrapper = new BlazeTextureViewWrapper(); /** * Can be set for special application shaders that need @@ -129,7 +125,7 @@ public class DhApplyRenderer GpuTexture destinationColorTexture) { this.createPipeline(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData(this.name); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData(this.name); this.sourceColorTextureViewWrapper.trySetup(sourceColorTexture); this.sourceDepthTextureViewWrapper.trySetup(sourceDepthTexture); @@ -145,7 +141,7 @@ public class DhApplyRenderer } VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index b53364e30..838e7a88b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -29,10 +29,10 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import net.minecraft.resources.Identifier; @@ -82,7 +82,7 @@ public class McCopyRenderer this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); @@ -106,7 +106,7 @@ public class McCopyRenderer this.pipeline = pipelineBuilder.build(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McCopyRenderer"); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData("McCopyRenderer"); } @@ -120,16 +120,16 @@ public class McCopyRenderer //region public void render( - McTextureWrapper sourceColorTextureWrapper, - McTextureViewWrapper destinationColorTextureWrapper) + BlazeTextureWrapper sourceColorTextureWrapper, + BlazeTextureViewWrapper destinationColorTextureWrapper) { this.render( sourceColorTextureWrapper.textureView, sourceColorTextureWrapper.textureSampler, destinationColorTextureWrapper.textureView); } public void render( - McTextureWrapper sourceColorTextureWrapper, - McTextureWrapper destinationColorTextureWrapper) + BlazeTextureWrapper sourceColorTextureWrapper, + BlazeTextureWrapper destinationColorTextureWrapper) { this.render( sourceColorTextureWrapper.textureView, sourceColorTextureWrapper.textureSampler, diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index c479f632f..1c92bfbce 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McInstancedVboContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -28,7 +28,7 @@ import java.util.function.Supplier; * * @see RenderableBoxGroup */ -public class McInstancedVboContainer implements IGenericObjectVertexBufferContainer +public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -290,7 +290,7 @@ public class McInstancedVboContainer implements IGenericObjectVertexBufferContai this.indexBuffer.flip(); - this.state = McInstancedVboContainer.EState.READY_TO_UPLOAD; + this.state = BlazeGenericObjectVertexContainer.EState.READY_TO_UPLOAD; } private int vertexBufferSize() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java index e30276f28..3e8554cc6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/PostProcessHelper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java @@ -10,7 +10,7 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.function.Supplier; -public class PostProcessHelper +public class BlazePostProcessUtil { private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java index 9686708ff..206025db6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java @@ -9,7 +9,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import java.util.OptionalDouble; -public class McTextureViewWrapper +public class BlazeTextureViewWrapper { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java similarity index 89% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java index bb508adee..7f1e2f42c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/McTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java @@ -12,7 +12,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRen import java.util.OptionalDouble; -public class McTextureWrapper +public class BlazeTextureWrapper { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -31,10 +31,10 @@ public class McTextureWrapper - public static McTextureWrapper createDepth(String name) { return new McTextureWrapper(name, TextureFormat.DEPTH32); } - public static McTextureWrapper createColor(String name) { return new McTextureWrapper(name, TextureFormat.RGBA8); } + public static BlazeTextureWrapper createDepth(String name) { return new BlazeTextureWrapper(name, TextureFormat.DEPTH32); } + public static BlazeTextureWrapper createColor(String name) { return new BlazeTextureWrapper(name, TextureFormat.RGBA8); } - private McTextureWrapper(String name, TextureFormat textureFormat) + private BlazeTextureWrapper(String name, TextureFormat textureFormat) { this.name = name; this.textureFormat = textureFormat; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java index 5cd213582..4582885d1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java @@ -6,7 +6,7 @@ import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuad /** * @see LodQuadBuilder */ -public class DhVertexFormat +public class DhBlazeVertexFormat { public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); public static final VertexFormatElement RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index 1e61939e0..3e998ae19 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -74,8 +74,8 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private GpuBuffer vboGpuBuffer; - public final McTextureWrapper dhFadeColorTextureWrapper = McTextureWrapper.createColor("DhFadeColorTexture"); - public final McTextureViewWrapper mcColorTextureViewWrapper = new McTextureViewWrapper(); + public final BlazeTextureWrapper dhFadeColorTextureWrapper = BlazeTextureWrapper.createColor("DhFadeColorTexture"); + public final BlazeTextureViewWrapper mcColorTextureViewWrapper = new BlazeTextureViewWrapper(); @@ -87,7 +87,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private McFarFadeRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); } @@ -131,7 +131,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer this.pipeline = pipelineBuilder.build(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFadeRenderer"); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData("McFadeRenderer"); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 428bde0c7..09498675b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -41,9 +41,9 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -88,7 +88,7 @@ public class McFogRenderer implements IMcFogRenderer private GpuBuffer vboGpuBuffer; - public McTextureWrapper fogColorTextureWrapper = McTextureWrapper.createColor("DhFogColorTexture"); + public BlazeTextureWrapper fogColorTextureWrapper = BlazeTextureWrapper.createColor("DhFogColorTexture"); @@ -100,7 +100,7 @@ public class McFogRenderer implements IMcFogRenderer private McFogRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); } @@ -149,7 +149,7 @@ public class McFogRenderer implements IMcFogRenderer this.pipeline = pipelineBuilder.build(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFogRenderer"); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData("McFogRenderer"); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index aed362df7..7db3f9c69 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -38,9 +38,9 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.PostProcessHelper; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -82,7 +82,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private GpuBuffer vboGpuBuffer; - public McTextureWrapper ssaoColorTextureWrapper = McTextureWrapper.createColor("DhSsaoTexture"); + public BlazeTextureWrapper ssaoColorTextureWrapper = BlazeTextureWrapper.createColor("DhSsaoTexture"); @@ -94,7 +94,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private McSsaoRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); } @@ -141,7 +141,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.pipeline = pipelineBuilder.build(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McSsao"); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData("McSsao"); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 08aca0595..7f0b50659 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -74,10 +74,10 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer private GpuBuffer vboGpuBuffer; - public final McTextureWrapper fadeColorTextureWrapper = McTextureWrapper.createColor("DhVanillaFadeTexture"); + public final BlazeTextureWrapper fadeColorTextureWrapper = BlazeTextureWrapper.createColor("DhVanillaFadeTexture"); - public final McTextureViewWrapper mcDepthTextureWrapper = new McTextureViewWrapper(); - public final McTextureViewWrapper mcColorTextureWrapper = new McTextureViewWrapper(); + public final BlazeTextureViewWrapper mcDepthTextureWrapper = new BlazeTextureViewWrapper(); + public final BlazeTextureViewWrapper mcColorTextureWrapper = new BlazeTextureViewWrapper(); @@ -89,7 +89,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer private McVanillaFadeRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); } @@ -134,7 +134,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer this.pipeline = pipelineBuilder.build(); - this.vboGpuBuffer = PostProcessHelper.createAndUploadScreenVertexData("McFadeRenderer"); + this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData("McFadeRenderer"); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index d15016f8d..3a4f0d7b3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -30,7 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; @@ -84,8 +84,8 @@ public class DhTestRenderer implements IMcTestRenderer VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhVertexFormat.SCREEN_POS) - .add("vColor", DhVertexFormat.RGBA_FLOAT_COLOR) + .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vColor", DhBlazeVertexFormat.RGBA_FLOAT_COLOR) .build(); //int breakpointOne = 0; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index cffbce4ec..c31afe887 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,7 +19,7 @@ package com.seibel.distanthorizons.common.wrappers; -import com.seibel.distanthorizons.common.render.blaze.McDebugObjectRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFogRenderer; @@ -86,7 +86,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, McFarFadeRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, McDebugObjectRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index ca36bce37..2d45c86d4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -26,7 +26,7 @@ import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.LodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.McInstancedVboContainer; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; import com.seibel.distanthorizons.common.render.blaze.helpers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; @@ -37,7 +37,6 @@ import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGeneratio import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; @@ -369,7 +368,7 @@ public class WrapperFactory implements IWrapperFactory public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodContainerUniformBufferWrapper(); } @Override - public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new McInstancedVboContainer(); } + public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } @Override public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index bd6978e13..d9219c6ae 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; -import com.seibel.distanthorizons.common.render.blaze.helpers.McTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; @@ -42,7 +42,7 @@ public class LightMapWrapper implements ILightMapWrapper private int textureId = 0; private GpuTexture gpuTexture = null; - private final McTextureViewWrapper lightmapTextureWrapper = new McTextureViewWrapper(); + private final BlazeTextureViewWrapper lightmapTextureWrapper = new BlazeTextureViewWrapper(); @@ -119,7 +119,7 @@ public class LightMapWrapper implements ILightMapWrapper //==============// //region - public McTextureViewWrapper getTextureViewWrapper() { return this.lightmapTextureWrapper; } + public BlazeTextureViewWrapper getTextureViewWrapper() { return this.lightmapTextureWrapper; } @Override public void bind() From 18acb5d10161b1aafb23353ea6b404283771f639 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:31:42 -0500 Subject: [PATCH 32/72] move blaze wrapper objects --- .../common/render/blaze/McGenericObjectRenderer.java | 2 +- .../distanthorizons/common/render/blaze/McLodRenderer.java | 3 +++ .../common/render/blaze/apply/DhApplyRenderer.java | 4 ++-- .../common/render/blaze/apply/McCopyRenderer.java | 6 +++--- .../render/blaze/postProcessing/McFarFadeRenderer.java | 3 +++ .../common/render/blaze/postProcessing/McFogRenderer.java | 4 ++-- .../common/render/blaze/postProcessing/McSsaoRenderer.java | 4 ++-- .../render/blaze/postProcessing/McVanillaFadeRenderer.java | 3 +++ .../blaze/{helpers => util}/BlazePostProcessUtil.java | 2 +- .../{helpers => wrappers}/BlazeTextureViewWrapper.java | 2 +- .../blaze/{helpers => wrappers}/BlazeTextureWrapper.java | 2 +- .../blaze/{helpers => wrappers}/VertexBufferWrapper.java | 3 +-- .../distanthorizons/common/wrappers/WrapperFactory.java | 2 +- .../common/wrappers/misc/LightMapWrapper.java | 2 +- 14 files changed, 25 insertions(+), 17 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => util}/BlazePostProcessUtil.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => wrappers}/BlazeTextureViewWrapper.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => wrappers}/BlazeTextureWrapper.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => wrappers}/VertexBufferWrapper.java (94%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 338bbbb20..7e6396767 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -44,7 +44,7 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 9373cd892..e4576027f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -18,6 +18,9 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index 64b1a5774..c9e56a072 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -32,8 +32,8 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.coreapi.ModInfo; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 838e7a88b..384f11acc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -30,9 +30,9 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import net.minecraft.resources.Identifier; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index 3e998ae19..a4b04e60d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -35,6 +35,9 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 09498675b..997616da2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -42,8 +42,8 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 7db3f9c69..925640e1a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -39,8 +39,8 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 7f0b50659..6e26d1c54 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -35,6 +35,9 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index 3e8554cc6..e4a773c6b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.util; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java index 206025db6..6538bfc12 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.wrappers; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java index 7f1e2f42c..714e32891 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.wrappers; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java similarity index 94% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java index 0972e4b58..852594d1f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.wrappers; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -8,7 +8,6 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; import java.nio.ByteBuffer; -import java.util.function.Supplier; public class VertexBufferWrapper implements IVertexBufferWrapper { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 2d45c86d4..023c8c016 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -27,7 +27,7 @@ import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.helpers.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index d9219c6ae..266d06c1a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; From 5c5de3c74409c869c1ec20d56689d1c234c6e16a Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:48:07 -0500 Subject: [PATCH 33/72] javadocs --- .../common/render/blaze/apply/DhApplyRenderer.java | 7 ++++++- .../common/render/blaze/apply/McCopyRenderer.java | 4 +++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index c9e56a072..539d1f8f6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -45,7 +45,12 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * TODO ??? + * Copies the given color texture + * where the depth (or another attribute) is valid. + * Often used to apply post processing effects or + * the DH texture to MC's color texture.

+ * + * @see McCopyRenderer */ public class DhApplyRenderer { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 384f11acc..83468db27 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -41,7 +41,9 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * TODO ??? + * Blindly copies one texture into another. + * + * @see DhApplyRenderer */ public class McCopyRenderer { From a2c96ba7ff1ca04dde83e15c9ac45cff4c88a28e Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:51:38 -0500 Subject: [PATCH 34/72] move vertex format --- .../blaze/BlazeDebugWireframeRenderer.java | 54 ++++++------------- .../render/blaze/McGenericObjectRenderer.java | 2 +- .../common/render/blaze/McLodRenderer.java | 1 + .../render/blaze/apply/DhApplyRenderer.java | 2 +- .../render/blaze/apply/McCopyRenderer.java | 6 +-- .../postProcessing/McFarFadeRenderer.java | 1 + .../blaze/postProcessing/McFogRenderer.java | 2 +- .../blaze/postProcessing/McSsaoRenderer.java | 2 +- .../postProcessing/McVanillaFadeRenderer.java | 1 + .../render/blaze/test/DhTestRenderer.java | 2 +- .../DhBlazeVertexFormat.java | 5 +- 11 files changed, 28 insertions(+), 50 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => util}/DhBlazeVertexFormat.java (82%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index be7c9a761..e10be3549 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -32,8 +32,8 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -120,6 +120,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer private GpuBuffer uniformBuffer; + //=============// // constructor // //=============// @@ -145,10 +146,6 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer } private void createPipelines() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); @@ -157,7 +154,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer pipelineBuilder.withColorWrite(true); pipelineBuilder.withoutBlend(); pipelineBuilder.withPolygonMode(PolygonMode.WIREFRAME); - pipelineBuilder.withLocation(Identifier.parse("distanthorizons:debug_renderer")); + pipelineBuilder.withLocation(Identifier.parse("distanthorizons:debug_wireframe_renderer")); pipelineBuilder.withVertexShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/blaze/vert")); pipelineBuilder.withFragmentShader(Identifier.fromNamespaceAndPath("distanthorizons", "debug/blaze/frag")); @@ -177,29 +174,23 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer boxVerticesBuffer.rewind(); MemoryUtil.memFree(boxVerticesBuffer); - - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - // upload vertex data { - Supplier labelSupplier = () -> "distantHorizons:McDebugRenderer"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; int size = BOX_VERTICES.length * Float.BYTES; - this.boxVertexBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + this.boxVertexBuffer = GPU_DEVICE.createBuffer(() -> "distantHorizons:McDebugWireframeBox", usage, size); { - int offset = 0; int length = BOX_VERTICES.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxVertexBuffer, offset, length); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxVertexBuffer, /*offset*/ 0, length); ByteBuffer byteBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES); - // Fill buffer with vertices. byteBuffer.order(ByteOrder.nativeOrder()); byteBuffer.asFloatBuffer().put(BOX_VERTICES); byteBuffer.rewind(); - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); } } @@ -211,15 +202,15 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer buffer.rewind(); - // TODO - // GpuBuffer.USAGE_UNIFORM = 128 - // GpuBuffer.USAGE_INDEX = 64 - int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.boxIndexBuffer = gpuDevice.createBuffer(() -> "DH Debug Index Buffer", usage, buffer.capacity()); + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_INDEX + | GpuBuffer.USAGE_UNIFORM; + this.boxIndexBuffer = GPU_DEVICE.createBuffer(() -> "DH Debug Index Buffer", usage, buffer.capacity()); int offset = 0; GpuBufferSlice bufferSlice = new GpuBufferSlice(this.boxIndexBuffer, offset, buffer.capacity()); - commandEncoder.writeToBuffer(bufferSlice, buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } } @@ -266,15 +257,6 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer - - //===========// - // rendering // - //===========// - //#region - - // validation // - - // uniforms { int uniformBufferSize = new Std140SizeCalculator() @@ -329,13 +311,13 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer this::getName, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) + McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { // Bind instance data // renderPass.setUniform("uniformBlock", this.uniformBuffer); - // set pipeline - renderPass.setPipeline(this.pipeline); // TODO + renderPass.setPipeline(this.pipeline); renderPass.setIndexBuffer(this.boxIndexBuffer, VertexFormat.IndexType.INT); renderPass.setVertexBuffer(0, this.boxVertexBuffer); @@ -346,8 +328,6 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer /*indexCount*/BOX_OUTLINE_INDICES.length, /*instanceCount*/1); } - //#endregion - } private String getName() { return "distantHorizons:McDebugRenderer"; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 7e6396767..dcf94e174 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -42,8 +42,8 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeG import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index e4576027f..38afa7c0b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -18,6 +18,7 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index 539d1f8f6..2469d2509 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -31,7 +31,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 83468db27..9c4019d44 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -29,7 +29,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -79,10 +79,6 @@ public class McCopyRenderer - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - this.vertexFormat = VertexFormat.builder() .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) .build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index a4b04e60d..ffd434296 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -36,6 +36,7 @@ import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 997616da2..71be2fd8f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -41,7 +41,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 925640e1a..2634525f4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -38,7 +38,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 6e26d1c54..13674e0e8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -36,6 +36,7 @@ import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index 3a4f0d7b3..bf0cfad07 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -30,7 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java similarity index 82% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java index 4582885d1..7989e4654 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/DhBlazeVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.util; import com.mojang.blaze3d.vertex.VertexFormatElement; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; @@ -20,8 +20,7 @@ public class DhBlazeVertexFormat public static final VertexFormatElement IRIS_NORMAL = VertexFormatElement.register(/*id*/14, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); public static final VertexFormatElement FLOAT_XYZ_POS = VertexFormatElement.register(/*id*/15, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 3); - public static final VertexFormatElement VEC3 = VertexFormatElement.register(/*id*/16, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.GENERIC, /*count*/ 3); - public static final VertexFormatElement IVEC3 = VertexFormatElement.register(/*id*/17, /*index*/0, VertexFormatElement.Type.INT, VertexFormatElement.Usage.GENERIC, /*count*/ 3); + } From 4d7674348ba85caccc1d8112355941e2b821d1ec Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 11:53:37 -0500 Subject: [PATCH 35/72] Move uniformbufferwrapper --- .../distanthorizons/common/render/blaze/McLodRenderer.java | 1 + .../LodContainerUniformBufferWrapper.java | 3 ++- .../seibel/distanthorizons/common/wrappers/WrapperFactory.java | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => wrappers}/LodContainerUniformBufferWrapper.java (91%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 38afa7c0b..b878ed8c9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -21,6 +21,7 @@ import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java similarity index 91% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java index 647162a76..01179a26d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/LodContainerUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java @@ -1,7 +1,8 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.wrappers; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; +import com.seibel.distanthorizons.common.render.blaze.helpers.AbstractUniformBufferWrapper; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.math.Mat4f; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 023c8c016..16264aef2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -25,7 +25,7 @@ import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiW import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.LodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; From afdccfe0878585b1ca6f3e602a18d04c4c7d5495 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 12:03:27 -0500 Subject: [PATCH 36/72] refactoring and cleanup --- .../render/blaze/McGenericObjectRenderer.java | 3 +- .../common/render/blaze/McLodRenderer.java | 23 +-- .../helpers/AbstractUniformBufferWrapper.java | 44 ++++-- .../BlazeGenericObjectVertexContainer.java | 143 ++---------------- .../render/blaze/helpers/UniformHandler.java | 15 +- .../postProcessing/BlazePostProcessUtil.java | 60 ++++++++ .../postProcessing/McFarFadeRenderer.java | 10 +- .../blaze/postProcessing/McFogRenderer.java | 5 - .../blaze/postProcessing/McSsaoRenderer.java | 5 - .../postProcessing/McVanillaFadeRenderer.java | 5 - .../render/blaze/test/DhTestRenderer.java | 14 +- .../blaze/util/BlazePostProcessUtil.java | 11 +- .../blaze/wrappers/BlazeTextureWrapper.java | 50 +++++- ...pper.java => LodUniformBufferWrapper.java} | 5 +- .../common/wrappers/WrapperFactory.java | 4 +- 15 files changed, 187 insertions(+), 210 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/{LodContainerUniformBufferWrapper.java => LodUniformBufferWrapper.java} (92%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index dcf94e174..37f226262 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -54,6 +54,7 @@ import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.render.renderer.generic.NativeGlGenericObjectVertexContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -528,7 +529,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //endregion } - private String getName() { return "distantHorizons:McTestRenderer"; } + private String getName() { return "distantHorizons:McGenericObjectRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index b878ed8c9..c6507fa7d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -21,7 +21,7 @@ import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.LodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.LodUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -286,10 +286,11 @@ public class McLodRenderer implements IMcLodRenderer if (this.indexBuffer == null || this.indexBuffer.size() < buffer.capacity()) { - // GpuBuffer.USAGE_UNIFORM = 128 - // GpuBuffer.USAGE_INDEX = 64 - int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.indexBuffer = GPU_DEVICE.createBuffer(() -> "DH Index Buffer", usage, buffer.capacity()); + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_INDEX + | GpuBuffer.USAGE_UNIFORM; + this.indexBuffer = GPU_DEVICE.createBuffer(this::getIndexBufferName, usage, buffer.capacity()); } int offset = 0; @@ -302,15 +303,6 @@ public class McLodRenderer implements IMcLodRenderer this.dhDepthTextureWrapper.trySetup(); this.dhColorTextureWrapper.trySetup(); - //LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - //this.mcLightTextureViewWrapper.trySetup(lightMapWrapper.gpuTexture); - - - //LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; - //McTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); - //renderPass.bindTexture("uLightMap", lightmapTextureViewWrapper.textureView, lightmapTextureViewWrapper.textureSampler); - - { profiler.popPush("setup"); @@ -346,7 +338,7 @@ public class McLodRenderer implements IMcLodRenderer profiler.popPush("binding"); LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - LodContainerUniformBufferWrapper uniformWrapper = (LodContainerUniformBufferWrapper)bufferContainer.uniforms; + LodUniformBufferWrapper uniformWrapper = (LodUniformBufferWrapper)bufferContainer.uniforms; boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get(); if (columnBuilderDebugEnabled) @@ -400,6 +392,7 @@ public class McLodRenderer implements IMcLodRenderer profiler.pop(); } + private String getIndexBufferName() { return "distantHorizons:LodIndexBuffer"; } private String getName() { return "distantHorizons:McLodRenderer"; } @Override diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java index e561b70e8..f83845802 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java @@ -16,6 +16,9 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + private final String name; @@ -23,30 +26,35 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap public GpuBuffer gpuBuffer = null; + //=============// + // constructor // + //=============// + //region + + public AbstractUniformBufferWrapper() { this.name = this.getClass().getSimpleName(); } + + //endregion + + //========// // render // //========// //region - public AbstractUniformBufferWrapper() { this.name = this.getClass().getSimpleName(); } - public AbstractUniformBufferWrapper(String name) { this.name = name; } - protected ByteBuffer getOrCreateBuffer(int size) { - GpuDevice gpuDevice = RenderSystem.getDevice(); - if (this.buffer == null || this.buffer.capacity() != size) { this.buffer = ByteBuffer.allocateDirect(size); this.buffer.order(ByteOrder.nativeOrder()); - // GpuBuffer.USAGE_UNIFORM = 128 - // GpuBuffer.USAGE_INDEX = 64 - int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_UNIFORM; int byteSize = (this.buffer.limit() - this.buffer.position()); - this.gpuBuffer = gpuDevice.createBuffer(this::getName, usage, byteSize); + this.gpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, byteSize); } return this.buffer; @@ -62,14 +70,11 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - int byteSize = (this.buffer.limit() - this.buffer.position()); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.gpuBuffer, /*offset*/0, byteSize); if (!bufferSlice.buffer().isClosed()) { - commandEncoder.writeToBuffer(bufferSlice, this.buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, this.buffer); } else { @@ -78,6 +83,15 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap } private String getName() { return this.name; } + //endregion + + + + //================// + // base overrides // + //================// + //region + @Override public void close() { @@ -87,8 +101,8 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap } } - - //endregion + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index 1c92bfbce..2dc1438ac 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -6,7 +6,6 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.glObject.GLEnums; @@ -14,14 +13,11 @@ import com.seibel.distanthorizons.core.render.glObject.GLProxy; import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.List; -import java.util.function.Supplier; /** * For use by {@link RenderableBoxGroup} @@ -32,48 +28,8 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - - /** A box from 0,0,0 to 1,1,1 */ - private static final float[] BOX_VERTICES = { - //region - // Pos x y z - - // min X, vertical face - 0, 0, 0, - 1, 0, 0, - 1, 1, 0, - 0, 1, 0, - // max X, vertical face - 0, 1, 1, - 1, 1, 1, - 1, 0, 1, - 0, 0, 1, - - // min Z, vertical face - 0, 0, 1, - 0, 0, 0, - 0, 1, 0, - 0, 1, 1, - // max Z, vertical face - 1, 0, 1, - 1, 1, 1, - 1, 1, 0, - 1, 0, 0, - - // min Y, horizontal face - 0, 0, 1, - 1, 0, 1, - 1, 0, 0, - 0, 0, 0, - // max Y, horizontal face - 0, 1, 1, - 1, 1, 1, - 1, 1, 0, - 0, 1, 0, - //endregion - }; + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); private static final int[] BOX_INDICES = { //region @@ -100,69 +56,11 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu //endregion }; - public static final int[][][] DIRECTION_VERTEX_IBO_QUAD = new int[][][] - ///region - { - // X,Z // - { // UP - {1, 0}, // 0 - {1, 1}, // 1 - {0, 1}, // 2 - {0, 0}, // 3 - }, - { // DOWN - {0, 0}, // 0 - {0, 1}, // 1 - {1, 1}, // 2 - {1, 0}, // 3 - }, - - // X,Y // - { // NORTH - {0, 0}, // 0 - {0, 1}, // 1 - {1, 1}, // 2 - - {1, 0}, // 3 - }, - { // SOUTH - {1, 0}, // 0 - {1, 1}, // 1 - {0, 1}, // 2 - - {0, 0}, // 3 - }, - - // Z,Y // - { // WEST - {0, 0}, // 0 - {1, 0}, // 1 - {1, 1}, // 2 - - {0, 1}, // 3 - }, - { // EAST - {0, 1}, // 0 - {1, 1}, // 1 - {1, 0}, // 2 - - {0, 0}, // 3 - }, - }; - ///endregion - - - public GpuBuffer vboGpuBuffer; public GpuBuffer indexGpuBuffer; - //public int[] chunkPosData = new int[0]; - //public float[] subChunkPosData = new float[0]; - ////public float[] scalingData = new float[0]; - //public float[] colorData = new float[0]; - //public int[] materialData = new int[0]; private ByteBuffer vertexBuffer = ByteBuffer.allocateDirect(0); private ByteBuffer indexBuffer = ByteBuffer.allocateDirect(0); @@ -208,10 +106,6 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu - //QuadElementBuffer.buildBuffer(quadCount, this.indexBuffer, GL32.GL_UNSIGNED_INT); - - - for (int boxIndex = 0; boxIndex < boxCount; boxIndex++) { // index @@ -227,7 +121,8 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu // vertex DhApiRenderableBox box = uploadBoxList.get(boxIndex); - final double[] boxVertices = { + final double[] boxVertices = + { //region // Pos x y z @@ -308,31 +203,23 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu int quadCount = this.uploadedBoxCount * 36; int byteSize = quadCount * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6; return byteSize; - - //int faceCount = this.uploadedBoxCount * 6; - //int vertexCount = faceCount * 6; - //int byteSize = vertexCount * Integer.BYTES; - //return byteSize; } public void uploadDataToGpu() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - // vertex { int totalVertexByteSize = this.vertexBufferSize(); if (this.vboGpuBuffer == null || this.vboGpuBuffer.size() < totalVertexByteSize) { - Supplier labelSupplier = () -> "distantHorizons:GenericContainerVertex"; - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, totalVertexByteSize); + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; + this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, totalVertexByteSize); } GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, totalVertexByteSize); - commandEncoder.writeToBuffer(bufferSlice, this.vertexBuffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, this.vertexBuffer); } // index @@ -341,21 +228,22 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu if (this.indexGpuBuffer == null || this.indexGpuBuffer.size() < totalVertexByteSize) { - Supplier labelSupplier = () -> "distantHorizons:GenericContainerIndex"; - // GpuBuffer.USAGE_UNIFORM = 128 - // GpuBuffer.USAGE_INDEX = 64 - int usage = 8 | 32 | 64 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - this.indexGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, totalVertexByteSize); + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_INDEX + | GpuBuffer.USAGE_UNIFORM; + this.indexGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, totalVertexByteSize); } int offset = 0; GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexGpuBuffer, offset, totalVertexByteSize); - commandEncoder.writeToBuffer(bufferSlice, this.indexBuffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, this.indexBuffer); } this.state = EState.RENDER; } + private String getName() { return "distantHorizons:GenericContainerIndex"; } //endregion @@ -375,6 +263,7 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu { this.vboGpuBuffer.close(); } + if (this.indexGpuBuffer != null) { this.indexGpuBuffer.close(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java index c24e89065..eeb70b9d4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java @@ -1,28 +1,33 @@ package com.seibel.distanthorizons.common.render.blaze.helpers; import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; @Deprecated // TODO use Uniform Wrapper instead public class UniformHandler { + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + public static GpuBuffer createBuffer(String uniformName, int size, GpuBuffer vboGpuBuffer) { - GpuDevice gpuDevice = RenderSystem.getDevice(); - // create VBO if needed if (vboGpuBuffer == null || vboGpuBuffer.size() < size) { - // TODO // GpuBuffer.USAGE_UNIFORM = 128 - int usage = 8 | 32 | 128; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side - vboGpuBuffer = gpuDevice.createBuffer(() -> uniformName, usage, size); + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_UNIFORM; + vboGpuBuffer = GPU_DEVICE.createBuffer(() -> uniformName, usage, size); } return vboGpuBuffer; } + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java new file mode 100644 index 000000000..574354191 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java @@ -0,0 +1,60 @@ +package com.seibel.distanthorizons.common.render.blaze.postProcessing; + +import com.mojang.blaze3d.buffers.GpuBuffer; +import com.mojang.blaze3d.buffers.GpuBufferSlice; +import com.mojang.blaze3d.systems.CommandEncoder; +import com.mojang.blaze3d.systems.GpuDevice; +import com.mojang.blaze3d.systems.RenderSystem; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.function.Supplier; + +/** + * Contains code that's used by all post-processing effects. + */ +public class BlazePostProcessUtil +{ + + private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + // vertices for a full-screen quad + private static final float[] VERTICES = new float[] + { + // PosX,Y, + -1f, -1f, + 1f, -1f, + 1f, 1f, + -1f, 1f, + }; + + + public static GpuBuffer createAndUploadScreenVertexData(String name) + { + Supplier labelSupplier = () -> "distantHorizons:"+name; + + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; + int size = VERTICES.length * Float.BYTES; + GpuBuffer vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); + + { + int length = VERTICES.length * Float.BYTES; + GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, /*offset*/ 0, length); + + ByteBuffer byteBuffer = ByteBuffer.allocateDirect(VERTICES.length * Float.BYTES); + // Fill buffer with vertices. + byteBuffer.order(ByteOrder.nativeOrder()); + byteBuffer.asFloatBuffer().put(VERTICES); + byteBuffer.rewind(); + + COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); + } + + return vboGpuBuffer; + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index ffd434296..c90c3939f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -105,11 +105,6 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); @@ -215,10 +210,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private void renderFadeToTexture() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - try (RenderPass renderPass = commandEncoder.createRenderPass( + try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( this::getName, this.dhFadeColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 71be2fd8f..081e94673 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -122,11 +122,6 @@ public class McFogRenderer implements IMcFogRenderer ); - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 2634525f4..13a2b3be8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -114,11 +114,6 @@ public class McSsaoRenderer implements IMcSsaoRenderer /*uniforms*/ new String[] { "applyFragUniformBlock" } ); - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 13674e0e8..ea47266e9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -107,11 +107,6 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index bf0cfad07..5efa6d390 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -41,7 +41,6 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * Renders the OpenGL/Vulkan triangle @@ -121,10 +120,6 @@ public class DhTestRenderer implements IMcTestRenderer } private void uploadVertexData() { - GpuDevice gpuDevice = RenderSystem.getDevice(); - CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); - - // vertices for the OpenGL/Vulkan Triangle float[] vertices = new float[] { @@ -135,11 +130,10 @@ public class DhTestRenderer implements IMcTestRenderer }; - Supplier labelSupplier = () -> "distantHorizons:DhTestRenderer"; - // TODO - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = gpuDevice.createBuffer(labelSupplier, usage, size); + this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, size); { int offset = 0; @@ -152,7 +146,7 @@ public class DhTestRenderer implements IMcTestRenderer byteBuffer.asFloatBuffer().put(vertices); byteBuffer.rewind(); - commandEncoder.writeToBuffer(bufferSlice, byteBuffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index e4a773c6b..1ca0709b8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -10,6 +10,9 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.function.Supplier; +/** + * Contains code that's used by all post-processing effects. + */ public class BlazePostProcessUtil { @@ -29,10 +32,10 @@ public class BlazePostProcessUtil public static GpuBuffer createAndUploadScreenVertexData(String name) { - Supplier labelSupplier = () -> "distantHorizons:"+name; - // TODO - int usage = 8 | 32; // is this just using OpenGL VBO flags?, if so I can't find it, supposedly GlDevice on Mojang's side + + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX; int size = VERTICES.length * Float.BYTES; GpuBuffer vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); @@ -52,4 +55,6 @@ public class BlazePostProcessUtil return vboGpuBuffer; } + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java index 714e32891..079701a2c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java @@ -1,5 +1,6 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers; +import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; @@ -29,8 +30,15 @@ public class BlazeTextureWrapper public GpuTextureView textureView = null; public GpuSampler textureSampler = null; + private int width = -1; + private int height = -1; + //=============// + // constructor // + //=============// + //region + public static BlazeTextureWrapper createDepth(String name) { return new BlazeTextureWrapper(name, TextureFormat.DEPTH32); } public static BlazeTextureWrapper createColor(String name) { return new BlazeTextureWrapper(name, TextureFormat.RGBA8); } @@ -40,10 +48,31 @@ public class BlazeTextureWrapper this.textureFormat = textureFormat; } + //endregion + + //=========// + // getters // + //=========// + //region + public boolean isEmpty() { return this.texture == null; } + /** @return -1 if the texture is null */ + public int getWidth() { return this.width; } + /** @return -1 if the texture is null */ + public int getHeight() { return this.height; } + + //endregion + + + + //=======// + // setup // + //=======// + //region + public void trySetup() { this.tryCreateTexture(); @@ -52,14 +81,11 @@ public class BlazeTextureWrapper private void tryCreateTexture() { int viewWidth = MC_RENDER.getTargetFramebufferViewportWidth(); - int textureWidth = (this.texture != null) ? this.texture.getWidth(0) : -1; - int viewHeight = MC_RENDER.getTargetFramebufferViewportHeight(); - int textureHeight = (this.texture != null) ? this.texture.getHeight(0) : -1; if (this.texture == null - || textureWidth != viewWidth - || textureHeight != viewHeight) + || this.width != viewWidth + || this.height != viewHeight) { if (this.texture != null) { @@ -67,8 +93,13 @@ public class BlazeTextureWrapper this.textureView.close(); } - // TODO USAGE_TEXTURE_BINDING = 4 - int usage = 4 | 8 | 32 | 128; + this.width = viewWidth; + this.height = viewHeight; + + int usage = GpuBuffer.USAGE_HINT_CLIENT_STORAGE + | GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_UNIFORM; this.texture = GPU_DEVICE.createTexture(this.name, usage, this.textureFormat, @@ -91,6 +122,10 @@ public class BlazeTextureWrapper } } + //endregion + + + /** @see ColorUtil#argbToInt */ public void clearColor(int clearArgbColor) @@ -100,6 +135,7 @@ public class BlazeTextureWrapper COMMAND_ENCODER.clearColorTexture(this.texture, clearArgbColor); } } + public void clearDepth(float depth) { if (this.texture != null) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java similarity index 92% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java index 01179a26d..bc7711ecd 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodContainerUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java @@ -12,7 +12,10 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUni import java.nio.ByteBuffer; -public class LodContainerUniformBufferWrapper extends AbstractUniformBufferWrapper implements ILodContainerUniformBufferWrapper +/** + * TODO ?? + */ +public class LodUniformBufferWrapper extends AbstractUniformBufferWrapper implements ILodContainerUniformBufferWrapper { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 16264aef2..4d3a23d2e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -25,8 +25,8 @@ import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiW import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; -import com.seibel.distanthorizons.common.render.blaze.wrappers.LodContainerUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.wrappers.LodUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; @@ -365,7 +365,7 @@ public class WrapperFactory implements IWrapperFactory @Override public IVertexBufferWrapper createVboWrapper(String name) { return new VertexBufferWrapper(name); } @Override - public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodContainerUniformBufferWrapper(); } + public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodUniformBufferWrapper(); } @Override public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } From 458cc9b505a92b4e183f6b1a5f083663c7258cc5 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 12:05:50 -0500 Subject: [PATCH 37/72] renaming --- .../blaze/BlazeDebugWireframeRenderer.java | 5 ++--- .../render/blaze/McGenericObjectRenderer.java | 9 ++++----- .../common/render/blaze/McLodRenderer.java | 16 ++++++++-------- .../render/blaze/apply/DhApplyRenderer.java | 4 ++-- .../render/blaze/apply/McCopyRenderer.java | 4 ++-- .../blaze/postProcessing/McFarFadeRenderer.java | 4 ++-- .../blaze/postProcessing/McFogRenderer.java | 4 ++-- .../blaze/postProcessing/McSsaoRenderer.java | 4 ++-- .../postProcessing/McVanillaFadeRenderer.java | 4 ++-- .../common/render/blaze/test/DhTestRenderer.java | 6 +++--- .../render/blaze/util/BlazePostProcessUtil.java | 12 +++++++++--- ...xFormat.java => DhBlazeVertexFormatUtil.java} | 2 +- 12 files changed, 39 insertions(+), 35 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/{DhBlazeVertexFormat.java => DhBlazeVertexFormatUtil.java} (98%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index e10be3549..318bf02be 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -33,7 +33,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -52,7 +52,6 @@ import java.nio.ByteOrder; import java.util.Collection; import java.util.OptionalDouble; import java.util.OptionalInt; -import java.util.function.Supplier; /** * TODO @@ -137,7 +136,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer this.init = true; this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.FLOAT_XYZ_POS) + .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) .build(); this.createPipelines(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 37f226262..cc087b737 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -43,7 +43,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; @@ -54,7 +54,6 @@ import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.NativeGlGenericObjectVertexContainer; import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -129,9 +128,9 @@ public class McGenericObjectRenderer implements IMcGenericRenderer this.init = true; this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.FLOAT_XYZ_POS) - .add("aColor", DhBlazeVertexFormat.RGBA_UBYTE_COLOR) - .add("aMaterial", DhBlazeVertexFormat.IRIS_MATERIAL) + .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) + .add("aColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) + .add("aMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) .build(); this.createPipelines(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index c6507fa7d..0955c5f1e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -18,7 +18,7 @@ import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.LodUniformBufferWrapper; @@ -91,13 +91,13 @@ public class McLodRenderer implements IMcLodRenderer private McLodRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SHORT_XYZ_POS) - .add("meta", DhBlazeVertexFormat.META) - .add("vColor", DhBlazeVertexFormat.RGBA_UBYTE_COLOR) - .add("irisMaterial", DhBlazeVertexFormat.IRIS_MATERIAL) - .add("irisNormal", DhBlazeVertexFormat.IRIS_NORMAL) - .add("paddingTwo", DhBlazeVertexFormat.BYTE_PAD) - .add("paddingThree", DhBlazeVertexFormat.BYTE_PAD) // padding is to make sure the format is a multiple of 4 + .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) + .add("meta", DhBlazeVertexFormatUtil.META) + .add("vColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) + .add("irisMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) + .add("irisNormal", DhBlazeVertexFormatUtil.IRIS_NORMAL) + .add("paddingTwo", DhBlazeVertexFormatUtil.BYTE_PAD) + .add("paddingThree", DhBlazeVertexFormatUtil.BYTE_PAD) // padding is to make sure the format is a multiple of 4 .build(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index 2469d2509..0350b81bb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -31,7 +31,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -146,7 +146,7 @@ public class DhApplyRenderer } VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 9c4019d44..0e34f32b4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -29,7 +29,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -80,7 +80,7 @@ public class McCopyRenderer this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index c90c3939f..7e8780c65 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -36,7 +36,7 @@ import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -91,7 +91,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private McFarFadeRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index 081e94673..e32bbd2f7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -41,7 +41,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; @@ -100,7 +100,7 @@ public class McFogRenderer implements IMcFogRenderer private McFogRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 13a2b3be8..f68a96c02 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -38,7 +38,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; @@ -94,7 +94,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private McSsaoRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index ea47266e9..0ceca3a01 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -36,7 +36,7 @@ import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -93,7 +93,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer private McVanillaFadeRenderer() { this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) .build(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index 5efa6d390..b183f39be 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -30,7 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormat; +import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; @@ -83,8 +83,8 @@ public class DhTestRenderer implements IMcTestRenderer VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormat.SCREEN_POS) - .add("vColor", DhBlazeVertexFormat.RGBA_FLOAT_COLOR) + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) + .add("vColor", DhBlazeVertexFormatUtil.RGBA_FLOAT_COLOR) .build(); //int breakpointOne = 0; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index 1ca0709b8..ebba9ecb0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -10,9 +10,7 @@ import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.util.function.Supplier; -/** - * Contains code that's used by all post-processing effects. - */ +/** Contains code that's used by all post-processing effects. */ public class BlazePostProcessUtil { @@ -30,6 +28,12 @@ public class BlazePostProcessUtil }; + + //=========// + // methods // + //=========// + //region + public static GpuBuffer createAndUploadScreenVertexData(String name) { Supplier labelSupplier = () -> "distantHorizons:"+name; @@ -55,6 +59,8 @@ public class BlazePostProcessUtil return vboGpuBuffer; } + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java index 7989e4654..d4e34b0fb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java @@ -6,7 +6,7 @@ import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuad /** * @see LodQuadBuilder */ -public class DhBlazeVertexFormat +public class DhBlazeVertexFormatUtil { public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); public static final VertexFormatElement RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); From 385d6919fbf115966d03bf30e8198789b91e90fa Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 12:09:10 -0500 Subject: [PATCH 38/72] texture method renaming --- .../common/render/blaze/McLodRenderer.java | 4 ++-- .../render/blaze/apply/DhApplyRenderer.java | 6 ++--- .../postProcessing/McFarFadeRenderer.java | 4 ++-- .../blaze/postProcessing/McFogRenderer.java | 2 +- .../blaze/postProcessing/McSsaoRenderer.java | 2 +- .../postProcessing/McVanillaFadeRenderer.java | 6 ++--- .../wrappers/BlazeTextureViewWrapper.java | 11 ++++++++-- .../blaze/wrappers/BlazeTextureWrapper.java | 22 ++++++++++++++----- .../common/wrappers/misc/LightMapWrapper.java | 2 +- 9 files changed, 39 insertions(+), 20 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 0955c5f1e..f676b786e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -300,8 +300,8 @@ public class McLodRenderer implements IMcLodRenderer } // textures - this.dhDepthTextureWrapper.trySetup(); - this.dhColorTextureWrapper.trySetup(); + this.dhDepthTextureWrapper.tryCreateOrResize(); + this.dhColorTextureWrapper.tryCreateOrResize(); { profiler.popPush("setup"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index 0350b81bb..a63e48858 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -132,10 +132,10 @@ public class DhApplyRenderer this.createPipeline(); this.vboGpuBuffer = BlazePostProcessUtil.createAndUploadScreenVertexData(this.name); - this.sourceColorTextureViewWrapper.trySetup(sourceColorTexture); - this.sourceDepthTextureViewWrapper.trySetup(sourceDepthTexture); + this.sourceColorTextureViewWrapper.tryWrap(sourceColorTexture); + this.sourceDepthTextureViewWrapper.tryWrap(sourceDepthTexture); - this.destinationColorTextureViewWrapper.trySetup(destinationColorTexture); + this.destinationColorTextureViewWrapper.tryWrap(destinationColorTexture); } private void createPipeline() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java index 7e8780c65..edab46e75 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java @@ -157,8 +157,8 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer // textures - this.dhFadeColorTextureWrapper.trySetup(); - this.mcColorTextureViewWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + this.dhFadeColorTextureWrapper.tryCreateOrResize(); + this.mcColorTextureViewWrapper.tryWrap(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); { int uniformBufferSize = new Std140SizeCalculator() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index e32bbd2f7..e1380b62a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -170,7 +170,7 @@ public class McFogRenderer implements IMcFogRenderer - this.fogColorTextureWrapper.trySetup(); + this.fogColorTextureWrapper.tryCreateOrResize(); { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index f68a96c02..031ff1450 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -163,7 +163,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer // textures - this.ssaoColorTextureWrapper.trySetup(); + this.ssaoColorTextureWrapper.tryCreateOrResize(); // frag uniforms { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 0ceca3a01..40fd2bb9f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -158,10 +158,10 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer // textures - this.fadeColorTextureWrapper.trySetup(); + this.fadeColorTextureWrapper.tryCreateOrResize(); - this.mcDepthTextureWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); - this.mcColorTextureWrapper.trySetup(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); + this.mcDepthTextureWrapper.tryWrap(Minecraft.getInstance().getMainRenderTarget().getDepthTexture()); + this.mcColorTextureWrapper.tryWrap(Minecraft.getInstance().getMainRenderTarget().getColorTexture()); { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java index 6538bfc12..eccf93226 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java @@ -17,13 +17,18 @@ public class BlazeTextureViewWrapper private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public GpuTextureView textureView = null; public GpuSampler textureSampler = null; - public void trySetup(GpuTexture texture) + //=======// + // setup // + //=======// + //region + + /** does nothing if the texture is already wrapped */ + public void tryWrap(GpuTexture texture) { this.tryRecreateTextureView(texture); this.tryCreateSampler(); @@ -54,6 +59,8 @@ public class BlazeTextureViewWrapper } } + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java index 079701a2c..fcc5be7fb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java @@ -34,9 +34,10 @@ public class BlazeTextureWrapper private int height = -1; - //=============// - // constructor // - //=============// + + //==============// + // constructors // + //==============// //region public static BlazeTextureWrapper createDepth(String name) { return new BlazeTextureWrapper(name, TextureFormat.DEPTH32); } @@ -73,7 +74,8 @@ public class BlazeTextureWrapper //=======// //region - public void trySetup() + /** does nothing if the texture is already created and the correct size */ + public void tryCreateOrResize() { this.tryCreateTexture(); this.tryCreateSampler(); @@ -126,8 +128,15 @@ public class BlazeTextureWrapper + //==========// + // clearing // + //==========// + //region - /** @see ColorUtil#argbToInt */ + /** + * Will throw an exception if not a color texture. + * @see ColorUtil#argbToInt + */ public void clearColor(int clearArgbColor) { if (this.texture != null) @@ -136,6 +145,7 @@ public class BlazeTextureWrapper } } + /** Will throw an exception if not a depth texture. */ public void clearDepth(float depth) { if (this.texture != null) @@ -144,6 +154,8 @@ public class BlazeTextureWrapper } } + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 266d06c1a..440f5b7aa 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -107,7 +107,7 @@ public class LightMapWrapper implements ILightMapWrapper public void setLightmapGpuTexture(GpuTexture gpuTexture) { this.gpuTexture = gpuTexture; - this.lightmapTextureWrapper.trySetup(this.gpuTexture); + this.lightmapTextureWrapper.tryWrap(this.gpuTexture); } //endregion From b04a308090d9c83bd213decf335c2d014ddfe02d Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 12:20:13 -0500 Subject: [PATCH 39/72] MC -> blaze renaming and getName() cleanup --- .../blaze/BlazeDebugWireframeRenderer.java | 4 +-- .../render/blaze/McGenericObjectRenderer.java | 4 +-- .../common/render/blaze/McLodRenderer.java | 9 +++-- .../render/blaze/apply/McCopyRenderer.java | 4 +-- .../helpers/AbstractUniformBufferWrapper.java | 4 +-- .../BlazeGenericObjectVertexContainer.java | 7 ++-- ...derer.java => BlazeDhFarFadeRenderer.java} | 34 ++++++++----------- .../blaze/postProcessing/McFogRenderer.java | 4 +-- .../blaze/postProcessing/McSsaoRenderer.java | 4 +-- .../render/blaze/test/DhTestRenderer.java | 6 ++-- .../common/wrappers/DependencySetup.java | 4 +-- coreSubProjects | 2 +- 12 files changed, 40 insertions(+), 46 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/{McFarFadeRenderer.java => BlazeDhFarFadeRenderer.java} (86%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 318bf02be..acd479e6a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -307,7 +307,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer // render // try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, @@ -328,7 +328,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer /*instanceCount*/1); } } - private String getName() { return "distantHorizons:McDebugRenderer"; } + private String getRenderPassName() { return "distantHorizons:McDebugRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index cc087b737..1f5b6c09b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -496,7 +496,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer profiler.push(boxGroup.getResourceLocationPath()); try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, @@ -528,7 +528,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //endregion } - private String getName() { return "distantHorizons:McGenericObjectRenderer"; } + private String getRenderPassName() { return "distantHorizons:McGenericObjectRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index f676b786e..b83f4b089 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -282,7 +282,7 @@ public class McLodRenderer implements IMcLodRenderer QuadElementBuffer.buildBuffer(LodBufferContainer.MAX_QUADS_PER_BUFFER, buffer, GL32.GL_UNSIGNED_INT); - // create VBO if needed + // create buffer if needed if (this.indexBuffer == null || this.indexBuffer.size() < buffer.capacity()) { @@ -293,8 +293,7 @@ public class McLodRenderer implements IMcLodRenderer this.indexBuffer = GPU_DEVICE.createBuffer(this::getIndexBufferName, usage, buffer.capacity()); } - int offset = 0; - GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexBuffer, offset, buffer.capacity()); + GpuBufferSlice bufferSlice = new GpuBufferSlice(this.indexBuffer, /*offset*/ 0, buffer.capacity()); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); } } @@ -311,7 +310,7 @@ public class McLodRenderer implements IMcLodRenderer OptionalDouble optionalDepthValueAsDouble = OptionalDouble.empty(); try(RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, this.dhColorTextureWrapper.textureView, optionalClearColorAsInt, this.dhDepthTextureWrapper.textureView, optionalDepthValueAsDouble) @@ -393,7 +392,7 @@ public class McLodRenderer implements IMcLodRenderer profiler.pop(); } private String getIndexBufferName() { return "distantHorizons:LodIndexBuffer"; } - private String getName() { return "distantHorizons:McLodRenderer"; } + private String getRenderPassName() { return "distantHorizons:McLodRenderer"; } @Override public void applyToMcTexture() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 0e34f32b4..358bfdb97 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -142,7 +142,7 @@ public class McCopyRenderer this.tryInit(); try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, destinationTextureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), /*depthTexture*/ null, @@ -157,7 +157,7 @@ public class McCopyRenderer } } - private String getName() { return "distantHorizons:McCopyRenderer"; } + private String getRenderPassName() { return "distantHorizons:McCopyRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java index f83845802..6f55ceae3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java @@ -54,7 +54,7 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap | GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_UNIFORM; int byteSize = (this.buffer.limit() - this.buffer.position()); - this.gpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, byteSize); + this.gpuBuffer = GPU_DEVICE.createBuffer(this::getBufferName, usage, byteSize); } return this.buffer; @@ -81,7 +81,7 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap LOGGER.warn("Uploading to buffer ["+this.name+"] failed due to already being closed"); } } - private String getName() { return this.name; } + private String getBufferName() { return this.name; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index 2dc1438ac..6384e970c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -215,7 +215,7 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu { int usage = GpuBuffer.USAGE_COPY_DST | GpuBuffer.USAGE_VERTEX; - this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, totalVertexByteSize); + this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getVertexBufferName, usage, totalVertexByteSize); } GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vboGpuBuffer, /*offset*/0, totalVertexByteSize); @@ -232,7 +232,7 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu | GpuBuffer.USAGE_VERTEX | GpuBuffer.USAGE_INDEX | GpuBuffer.USAGE_UNIFORM; - this.indexGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, totalVertexByteSize); + this.indexGpuBuffer = GPU_DEVICE.createBuffer(this::getIndexBufferName, usage, totalVertexByteSize); } int offset = 0; @@ -243,7 +243,8 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu this.state = EState.RENDER; } - private String getName() { return "distantHorizons:GenericContainerIndex"; } + private String getVertexBufferName() { return "distantHorizons:GenericVertexBuffer"; } + private String getIndexBufferName() { return "distantHorizons:GenericIndexBuffer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java similarity index 86% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index edab46e75..f9c3123c0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -39,13 +39,11 @@ import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFarFadeRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -56,19 +54,16 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * Renders a TODO + * Fades out DH's far clip plane */ -public class McFarFadeRenderer implements IMcFarFadeRenderer +public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); - private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McFarFadeRenderer INSTANCE = new McFarFadeRenderer(); + public static final BlazeDhFarFadeRenderer INSTANCE = new BlazeDhFarFadeRenderer(); private VertexFormat vertexFormat; private RenderPipeline pipeline; @@ -88,7 +83,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer //=============// //region - private McFarFadeRenderer() + private BlazeDhFarFadeRenderer() { this.vertexFormat = VertexFormat.builder() .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) @@ -142,8 +137,8 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer //========// //region - @Override // TODO can probably just be DH mvm/proj matricies - public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + @Override + public void render(RenderParams renderParams) { this.tryInit(); @@ -175,13 +170,12 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer float fadeEndDistance = dhFarClipDistance * 0.9f; - Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); - Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(renderParams.mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(renderParams.mcModelViewMatrix); - Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); - inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); - inverseDhModelViewProjectionMatrix.invert(); - Mat4f inverseDhMvmProjMatrix = inverseDhModelViewProjectionMatrix; + Mat4f inverseDhMvmProjMatrix = new Mat4f(dhProjectionMatrix); + inverseDhMvmProjMatrix.multiply(dhModelViewMatrix); + inverseDhMvmProjMatrix.invert(); @@ -211,7 +205,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer private void renderFadeToTexture() { try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, this.dhFadeColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), /*depthTexture*/ null, @@ -232,7 +226,7 @@ public class McFarFadeRenderer implements IMcFarFadeRenderer renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } - private String getName() { return "distantHorizons:McFadeRenderer"; } + private String getRenderPassName() { return "distantHorizons:McFadeRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index e1380b62a..deb7e7fd7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -339,7 +339,7 @@ public class McFogRenderer implements IMcFogRenderer private void renderFogToTexture() { try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, this.fogColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), /*depthTexture*/ null, @@ -355,7 +355,7 @@ public class McFogRenderer implements IMcFogRenderer renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } - private String getName() { return "distantHorizons:McFogRenderer"; } + private String getRenderPassName() { return "distantHorizons:McFogRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 031ff1450..4cdea47d3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -260,7 +260,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer private void renderSsaoToTexture() { try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, this.ssaoColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), /*depthTexture*/ null, @@ -276,7 +276,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 4); } } - private String getName() { return "distantHorizons:McSsaoRenderer"; } + private String getRenderPassName() { return "distantHorizons:McSsaoRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java index b183f39be..21dc44b89 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java @@ -133,7 +133,7 @@ public class DhTestRenderer implements IMcTestRenderer int usage = GpuBuffer.USAGE_COPY_DST | GpuBuffer.USAGE_VERTEX; int size = vertices.length * Float.BYTES; - this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getName, usage, size); + this.vboGpuBuffer = GPU_DEVICE.createBuffer(this::getRenderPassName, usage, size); { int offset = 0; @@ -164,7 +164,7 @@ public class DhTestRenderer implements IMcTestRenderer this.tryInit(); try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( - this::getName, + this::getRenderPassName, this.mcColorTextureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), /*mcDepthTextureView*/ null, @@ -175,7 +175,7 @@ public class DhTestRenderer implements IMcTestRenderer renderPass.draw(/*indexStart*/ 0, /*indexCount*/ 3); } } - private String getName() { return "distantHorizons:DhTestRenderer"; } + private String getRenderPassName() { return "distantHorizons:DhTestRenderer"; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index c31afe887..ee3ca7850 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFarFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFogRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McSsaoRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McVanillaFadeRenderer; @@ -85,7 +85,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, McFarFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } diff --git a/coreSubProjects b/coreSubProjects index a8c15d22c..fee0aadcb 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit a8c15d22c34df7fe12ada0eb8853867bc7aaa5f8 +Subproject commit fee0aadcbe9d82b9cf6e210b90beb6e08e4ffe44 From e530d0ffda51a69f30a688af9852cfc95dff2cb4 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 12:28:58 -0500 Subject: [PATCH 40/72] wrapper movement --- .../render/blaze/McGenericObjectRenderer.java | 6 ++-- .../common/render/blaze/McLodRenderer.java | 8 ++--- .../render/blaze/apply/DhApplyRenderer.java | 2 +- .../render/blaze/apply/McCopyRenderer.java | 4 +-- .../BlazeDhFarFadeRenderer.java | 4 +-- .../blaze/postProcessing/McFogRenderer.java | 2 +- .../blaze/postProcessing/McSsaoRenderer.java | 2 +- .../postProcessing/McVanillaFadeRenderer.java | 4 +-- .../{ => buffer}/VertexBufferWrapper.java | 2 +- .../BlazeTextureViewWrapper.java | 2 +- .../{ => texture}/BlazeTextureWrapper.java | 2 +- .../AbstractUniformBufferWrapper.java | 3 +- .../LodUniformBufferWrapper.java | 3 +- .../common/wrappers/WrapperFactory.java | 35 ++++++++++++------- .../common/wrappers/misc/LightMapWrapper.java | 2 +- coreSubProjects | 2 +- 16 files changed, 46 insertions(+), 37 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/{ => buffer}/VertexBufferWrapper.java (96%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/{ => texture}/BlazeTextureViewWrapper.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/{ => texture}/BlazeTextureWrapper.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => wrappers/uniform}/AbstractUniformBufferWrapper.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/{ => uniform}/LodUniformBufferWrapper.java (91%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java index 1f5b6c09b..9d303b8f1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java @@ -44,7 +44,7 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -397,7 +397,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer boxGroup.tryUpdateInstancedDataAsync(); // skip groups that haven't been uploaded yet - if (boxGroup.instancedVbos.getState() != IGenericObjectVertexBufferContainer.EState.RENDER) + if (boxGroup.vertexBufferContainer.getState() != IGenericObjectVertexBufferContainer.EState.RENDER) { continue; } @@ -548,7 +548,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer profiler.push("vertex setup"); - BlazeGenericObjectVertexContainer container = (BlazeGenericObjectVertexContainer) boxGroup.instancedVbos; + BlazeGenericObjectVertexContainer container = (BlazeGenericObjectVertexContainer) boxGroup.vertexBufferContainer; LightMapWrapper lightMapWrapper = (LightMapWrapper) renderEventParam.lightmap; BlazeTextureViewWrapper lightmapTextureViewWrapper = lightMapWrapper.getTextureViewWrapper(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index b83f4b089..28ef2d342 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -19,10 +19,10 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.LodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.LodUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java index a63e48858..2f5478c71 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java @@ -32,7 +32,7 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 358bfdb97..4dbd4aa44 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -30,8 +30,8 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index f9c3123c0..816b43537 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -37,8 +37,8 @@ import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.renderer.RenderParams; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java index deb7e7fd7..b4bfca676 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java @@ -42,7 +42,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.config.Config; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index 4cdea47d3..f0e9db5c1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -39,7 +39,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 40fd2bb9f..8eb518c88 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -37,8 +37,8 @@ import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java index 852594d1f..c4c0f5c76 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.wrappers; +package com.seibel.distanthorizons.common.render.blaze.wrappers.buffer; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java index eccf93226..991982410 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.wrappers; +package com.seibel.distanthorizons.common.render.blaze.wrappers.texture; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java index fcc5be7fb..60557565c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/BlazeTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.wrappers; +package com.seibel.distanthorizons.common.render.blaze.wrappers.texture; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.CommandEncoder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java index 6f55ceae3..f342dcf54 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.wrappers.uniform; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -26,6 +26,7 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap public GpuBuffer gpuBuffer = null; + //=============// // constructor // //=============// diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java similarity index 91% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java index bc7711ecd..f0677a1c2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/LodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java @@ -1,8 +1,7 @@ -package com.seibel.distanthorizons.common.render.blaze.wrappers; +package com.seibel.distanthorizons.common.render.blaze.wrappers.uniform; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; -import com.seibel.distanthorizons.common.render.blaze.helpers.AbstractUniformBufferWrapper; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.render.renderer.RenderParams; import com.seibel.distanthorizons.core.util.math.Mat4f; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 4d3a23d2e..8471bedf6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -26,8 +26,8 @@ import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.wrappers.LodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.LodUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; @@ -72,6 +72,7 @@ public class WrapperFactory implements IWrapperFactory //==============// // core methods // //==============// + //region @Override public IBatchGeneratorEnvironmentWrapper createBatchGenerator(IDhLevel targetLevel) @@ -218,10 +219,25 @@ public class WrapperFactory implements IWrapperFactory } + @Override + public IVertexBufferWrapper createVboWrapper(String name) { return new VertexBufferWrapper(name); } + @Override + public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodUniformBufferWrapper(); } + + @Override + public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } + + @Override + public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } + + //endregion + + //=============// // api methods // //=============// + //region // documentation should be in the API interface @@ -320,12 +336,15 @@ public class WrapperFactory implements IWrapperFactory return createWrapperErrorMessage("BlockState wrapper", expectedClassNames, objectArray); } + //endregion + //================// // helper methods // //================// + //region private static String createWrapperErrorMessage(String wrapperName, String[] expectedClassNames, Object[] objectArray) { @@ -361,17 +380,7 @@ public class WrapperFactory implements IWrapperFactory return message.toString(); } - - @Override - public IVertexBufferWrapper createVboWrapper(String name) { return new VertexBufferWrapper(name); } - @Override - public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodUniformBufferWrapper(); } - - @Override - public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } - - @Override - public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } + //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 440f5b7aa..9ae35a965 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; -import com.seibel.distanthorizons.common.render.blaze.wrappers.BlazeTextureViewWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; diff --git a/coreSubProjects b/coreSubProjects index fee0aadcb..39dd1c850 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit fee0aadcbe9d82b9cf6e210b90beb6e08e4ffe44 +Subproject commit 39dd1c8509c23facf77ef9cafc5364a0908dd71f From 77016de6e638302e42b8cd9009c5efdd2656be0f Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 13:52:05 -0500 Subject: [PATCH 41/72] Only upload unique LOD uniforms once --- .../common/render/blaze/McLodRenderer.java | 10 ++-- .../uniform/LodUniformBufferWrapper.java | 42 +++++++++++----- ...Wrapper.java => UniformBufferWrapper.java} | 48 ++++++++++++------- coreSubProjects | 2 +- 4 files changed, 71 insertions(+), 31 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/{AbstractUniformBufferWrapper.java => UniformBufferWrapper.java} (64%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 28ef2d342..eedda4dd5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -180,8 +180,7 @@ public class McLodRenderer implements IMcLodRenderer for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) { LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - bufferContainer.uniforms.createBufferData(renderEventParam, bufferContainer); - bufferContainer.uniforms.upload(); + bufferContainer.uniformContainer.tryUpload(); } } @@ -211,6 +210,7 @@ public class McLodRenderer implements IMcLodRenderer .putFloat() // uMircoOffset .putFloat() // uEarthRadius + .putVec3() // uCameraPos .putMat4f() // uCombinedMatrix .get(); @@ -223,6 +223,10 @@ public class McLodRenderer implements IMcLodRenderer .putFloat(0.01f) // uMircoOffset // 0.01 block offset .putFloat(earthCurveRatio) // uEarthRadius + .putVec3( + (float)renderEventParam.exactCameraPosition.x, + (float)renderEventParam.exactCameraPosition.y, + (float)renderEventParam.exactCameraPosition.z) // uCameraPos .putMat4f(combinedMatrix.createJomlMatrix()) // uCombinedMatrix .get(); @@ -337,7 +341,7 @@ public class McLodRenderer implements IMcLodRenderer profiler.popPush("binding"); LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - LodUniformBufferWrapper uniformWrapper = (LodUniformBufferWrapper)bufferContainer.uniforms; + LodUniformBufferWrapper uniformWrapper = (LodUniformBufferWrapper)bufferContainer.uniformContainer; boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get(); if (columnBuilderDebugEnabled) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java index f0677a1c2..ea7017619 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java @@ -14,9 +14,21 @@ import java.nio.ByteBuffer; /** * TODO ?? */ -public class LodUniformBufferWrapper extends AbstractUniformBufferWrapper implements ILodContainerUniformBufferWrapper +public class LodUniformBufferWrapper extends UniformBufferWrapper implements ILodContainerUniformBufferWrapper { + private boolean uploaded = false; + + + + //=============// + // constructor // + //=============// + //region + + public LodUniformBufferWrapper() { super(LodUniformBufferWrapper.class.getName()); } + + //endregion @@ -25,18 +37,13 @@ public class LodUniformBufferWrapper extends AbstractUniformBufferWrapper implem //========// //region - public void createBufferData(RenderParams renderEventParam, LodBufferContainer bufferContainer) + @Override + public void createUniformData(LodBufferContainer bufferContainer) { - Vec3d camPos = renderEventParam.exactCameraPosition; Vec3f modelOffset = new Vec3f( - (float) (bufferContainer.minCornerBlockPos.getX() - camPos.x), - (float) (bufferContainer.minCornerBlockPos.getY() - camPos.y), - (float) (bufferContainer.minCornerBlockPos.getZ() - camPos.z)); - - - Mat4f combinedMatrix = new Mat4f(renderEventParam.dhProjectionMatrix); - combinedMatrix.multiply(renderEventParam.dhModelViewMatrix); - + (float) (bufferContainer.minCornerBlockPos.getX()), + (float) (bufferContainer.minCornerBlockPos.getY()), + (float) (bufferContainer.minCornerBlockPos.getZ())); // upload data // @@ -51,6 +58,19 @@ public class LodUniformBufferWrapper extends AbstractUniformBufferWrapper implem } + @Override + public void tryUpload() + { + if (this.uploaded) + { + return; + } + + this.upload(); + + this.uploaded = true; + } + //endregion } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java similarity index 64% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java index f342dcf54..37b6388c1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/AbstractUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java @@ -5,6 +5,7 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; @@ -12,7 +13,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWr import java.nio.ByteBuffer; import java.nio.ByteOrder; -public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrapper +public class UniformBufferWrapper implements IUniformBufferWrapper { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -22,7 +23,10 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap private final String name; - private ByteBuffer buffer = null; + private int cpuBufferSize = 0; + private int gpuBufferSize = 0; + + private ByteBuffer cpuBuffer = null; public GpuBuffer gpuBuffer = null; @@ -32,7 +36,7 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap //=============// //region - public AbstractUniformBufferWrapper() { this.name = this.getClass().getSimpleName(); } + public UniformBufferWrapper(String name) { this.name = name; } //endregion @@ -45,37 +49,49 @@ public abstract class AbstractUniformBufferWrapper implements IUniformBufferWrap protected ByteBuffer getOrCreateBuffer(int size) { - if (this.buffer == null - || this.buffer.capacity() != size) + if (this.cpuBuffer == null + || this.cpuBufferSize != size) { - this.buffer = ByteBuffer.allocateDirect(size); - this.buffer.order(ByteOrder.nativeOrder()); + this.cpuBuffer = ByteBuffer.allocateDirect(size); + this.cpuBuffer.order(ByteOrder.nativeOrder()); - int usage = GpuBuffer.USAGE_COPY_DST - | GpuBuffer.USAGE_VERTEX - | GpuBuffer.USAGE_UNIFORM; - int byteSize = (this.buffer.limit() - this.buffer.position()); - this.gpuBuffer = GPU_DEVICE.createBuffer(this::getBufferName, usage, byteSize); + this.cpuBufferSize = size; } - return this.buffer; + return this.cpuBuffer; } @Override public void upload() throws IllegalStateException { - if (this.buffer == null) + if (this.cpuBuffer == null) { throw new IllegalStateException("Upload called before buffer was created"); } + if (this.gpuBuffer == null + || this.gpuBufferSize != this.cpuBufferSize) + { + if (this.gpuBuffer != null) + { + this.gpuBuffer.close(); + } + + int usage = GpuBuffer.USAGE_COPY_DST + | GpuBuffer.USAGE_VERTEX + | GpuBuffer.USAGE_UNIFORM; + this.gpuBuffer = GPU_DEVICE.createBuffer(this::getBufferName, usage, this.cpuBufferSize); + + this.gpuBufferSize = this.cpuBufferSize; + } - int byteSize = (this.buffer.limit() - this.buffer.position()); + + int byteSize = (this.cpuBuffer.limit() - this.cpuBuffer.position()); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.gpuBuffer, /*offset*/0, byteSize); if (!bufferSlice.buffer().isClosed()) { - COMMAND_ENCODER.writeToBuffer(bufferSlice, this.buffer); + COMMAND_ENCODER.writeToBuffer(bufferSlice, this.cpuBuffer); } else { diff --git a/coreSubProjects b/coreSubProjects index 39dd1c850..e1a932cf3 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 39dd1c8509c23facf77ef9cafc5364a0908dd71f +Subproject commit e1a932cf38e5f8f016a20fe946f5a792884333a3 From f7b5b9a2f54f54a3631e296139fd0a5854c684c3 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 13:58:48 -0500 Subject: [PATCH 42/72] merge postprocessing vertex format --- .../blaze/BlazeDebugWireframeRenderer.java | 9 ++------- .../render/blaze/apply/McCopyRenderer.java | 8 +------- .../postProcessing/BlazeDhFarFadeRenderer.java | 10 ++-------- ...FogRenderer.java => BlazeDhFogRenderer.java} | 17 +++++------------ .../blaze/postProcessing/McSsaoRenderer.java | 10 ++-------- .../postProcessing/McVanillaFadeRenderer.java | 10 ++-------- .../render/blaze/util/BlazePostProcessUtil.java | 9 +++++++++ .../common/wrappers/DependencySetup.java | 4 ++-- coreSubProjects | 2 +- 9 files changed, 26 insertions(+), 53 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/{McFogRenderer.java => BlazeDhFogRenderer.java} (96%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index acd479e6a..7a92769c4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -33,6 +33,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -109,8 +110,6 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer // rendering setup private boolean init = false; - private VertexFormat vertexFormat; - private RenderPipeline pipeline; private GpuBuffer boxVertexBuffer; @@ -135,10 +134,6 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer } this.init = true; - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) - .build(); - this.createPipelines(); this.createBuffers(); @@ -160,7 +155,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer pipelineBuilder.withUniform("uniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.DEBUG_LINES); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.DEBUG_LINES); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java index 4dbd4aa44..c8585d3dc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java @@ -54,7 +54,6 @@ public class McCopyRenderer public static final McCopyRenderer INSTANCE = new McCopyRenderer(); - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -79,11 +78,6 @@ public class McCopyRenderer - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .build(); - - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); @@ -99,7 +93,7 @@ public class McCopyRenderer pipelineBuilder.withSampler("uCopyTexture"); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index 816b43537..536893254 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -65,7 +65,6 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer public static final BlazeDhFarFadeRenderer INSTANCE = new BlazeDhFarFadeRenderer(); - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -83,12 +82,7 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer //=============// //region - private BlazeDhFarFadeRenderer() - { - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .build(); - } + private BlazeDhFarFadeRenderer() { } private void tryInit() { @@ -120,7 +114,7 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index b4bfca676..148cefde5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -63,9 +63,9 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * Renders a TODO + * Renders fog onto the LODs. */ -public class McFogRenderer implements IMcFogRenderer +public class BlazeDhFogRenderer implements IMcFogRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -75,12 +75,11 @@ public class McFogRenderer implements IMcFogRenderer private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McFogRenderer INSTANCE = new McFogRenderer(); + public static final BlazeDhFogRenderer INSTANCE = new BlazeDhFogRenderer(); private DhApplyRenderer applyRenderer; - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -97,12 +96,7 @@ public class McFogRenderer implements IMcFogRenderer //=============// //region - private McFogRenderer() - { - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .build(); - } + private BlazeDhFogRenderer() { } private void tryInit() { @@ -121,7 +115,6 @@ public class McFogRenderer implements IMcFogRenderer "apply/blaze/vert", "apply/blaze/frag" ); - RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); @@ -139,7 +132,7 @@ public class McFogRenderer implements IMcFogRenderer pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java index f0e9db5c1..b13d71935 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java @@ -73,7 +73,6 @@ public class McSsaoRenderer implements IMcSsaoRenderer private DhApplyRenderer applyRenderer; - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -91,12 +90,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer //=============// //region - private McSsaoRenderer() - { - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .build(); - } + private McSsaoRenderer() { } private void tryInit() { @@ -131,7 +125,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java index 8eb518c88..0e13bc59c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java @@ -70,7 +70,6 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer public static final McVanillaFadeRenderer INSTANCE = new McVanillaFadeRenderer(); - private VertexFormat vertexFormat; private RenderPipeline pipeline; private boolean init = false; @@ -90,12 +89,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer //=============// //region - private McVanillaFadeRenderer() - { - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .build(); - } + private McVanillaFadeRenderer() { } private void tryInit() { @@ -128,7 +122,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLE_FAN); + pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.TRIANGLE_FAN); } this.pipeline = pipelineBuilder.build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index ebba9ecb0..b14e861a0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -5,6 +5,7 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; +import com.mojang.blaze3d.vertex.VertexFormat; import java.nio.ByteBuffer; import java.nio.ByteOrder; @@ -59,6 +60,14 @@ public class BlazePostProcessUtil return vboGpuBuffer; } + public static VertexFormat createVertexFormat() + { + VertexFormat vertexFormat = VertexFormat.builder() + .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) + .build(); + return vertexFormat; + } + //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index ee3ca7850..ae74fa0e9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -22,7 +22,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.McFogRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McSsaoRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.McVanillaFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.test.DhTestRenderer; @@ -84,7 +84,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, McVanillaFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, McFogRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, BlazeDhFogRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } diff --git a/coreSubProjects b/coreSubProjects index e1a932cf3..8240101a4 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit e1a932cf38e5f8f016a20fe946f5a792884333a3 +Subproject commit 8240101a461472c8de1ba845deea28d69bfe3aeb From 7e19f9e6eb59ccb9bf98a80b6b9c5a74cbdd2e0c Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 14:07:03 -0500 Subject: [PATCH 43/72] MC -> Blaze renaming --- ...java => BlazeDhGenericObjectRenderer.java} | 4 +- .../common/render/blaze/McLodRenderer.java | 14 ++--- ...enderer.java => BlazeDhApplyRenderer.java} | 8 +-- ...Renderer.java => BlazeDhCopyRenderer.java} | 9 ++- .../BlazeDhFarFadeRenderer.java | 5 +- .../postProcessing/BlazeDhFogRenderer.java | 7 +-- ...Renderer.java => BlazeDhSsaoRenderer.java} | 17 +++--- .../postProcessing/BlazePostProcessUtil.java | 60 ------------------- ...rer.java => BlazeVanillaFadeRenderer.java} | 14 ++--- ...Renderer.java => BlazeDhTestRenderer.java} | 6 +- ...per.java => BlazeVertexBufferWrapper.java} | 4 +- ...java => BlazeLodUniformBufferWrapper.java} | 10 +--- .../uniform/UniformBufferWrapper.java | 1 - .../common/wrappers/DependencySetup.java | 12 ++-- .../common/wrappers/WrapperFactory.java | 12 ++-- 15 files changed, 55 insertions(+), 128 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{McGenericObjectRenderer.java => BlazeDhGenericObjectRenderer.java} (99%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/{DhApplyRenderer.java => BlazeDhApplyRenderer.java} (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/{McCopyRenderer.java => BlazeDhCopyRenderer.java} (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/{McSsaoRenderer.java => BlazeDhSsaoRenderer.java} (95%) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/{McVanillaFadeRenderer.java => BlazeVanillaFadeRenderer.java} (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/{DhTestRenderer.java => BlazeDhTestRenderer.java} (96%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/{VertexBufferWrapper.java => BlazeVertexBufferWrapper.java} (92%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/{LodUniformBufferWrapper.java => BlazeLodUniformBufferWrapper.java} (77%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java similarity index 99% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index 9d303b8f1..ce1db4375 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -80,7 +80,7 @@ import java.util.concurrent.ConcurrentHashMap; * @see IDhApiCustomRenderRegister * @see DhApiRenderableBox */ -public class McGenericObjectRenderer implements IMcGenericRenderer +public class BlazeDhGenericObjectRenderer implements IMcGenericRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -117,7 +117,7 @@ public class McGenericObjectRenderer implements IMcGenericRenderer //=============// //region - public McGenericObjectRenderer() { } + public BlazeDhGenericObjectRenderer() { } public void init() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index eedda4dd5..129a6dd43 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -16,13 +16,13 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.LodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; @@ -66,7 +66,7 @@ public class McLodRenderer implements IMcLodRenderer public static final McLodRenderer INSTANCE = new McLodRenderer(); - private DhApplyRenderer applyRenderer; + private BlazeDhApplyRenderer applyRenderer; private VertexFormat vertexFormat; private RenderPipeline opaquePipeline; @@ -110,7 +110,7 @@ public class McLodRenderer implements IMcLodRenderer this.init = true; // todo only set when succeeded (in case of exception) - this.applyRenderer = new DhApplyRenderer( + this.applyRenderer = new BlazeDhApplyRenderer( "dh_apply_to_mc", null, "apply/blaze/vert", "apply/blaze/frag" @@ -341,7 +341,7 @@ public class McLodRenderer implements IMcLodRenderer profiler.popPush("binding"); LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - LodUniformBufferWrapper uniformWrapper = (LodUniformBufferWrapper)bufferContainer.uniformContainer; + BlazeLodUniformBufferWrapper uniformWrapper = (BlazeLodUniformBufferWrapper)bufferContainer.uniformContainer; boolean columnBuilderDebugEnabled = Config.Client.Advanced.Debugging.ColumnBuilderDebugging.columnBuilderDebugEnable.get(); if (columnBuilderDebugEnabled) @@ -368,7 +368,7 @@ public class McLodRenderer implements IMcLodRenderer IVertexBufferWrapper[] bufferWrapperList = opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent; for (int i = 0; i < bufferWrapperList.length; i++) { - VertexBufferWrapper bufferWrapper = (VertexBufferWrapper) bufferWrapperList[i]; + BlazeVertexBufferWrapper bufferWrapper = (BlazeVertexBufferWrapper) bufferWrapperList[i]; if (!bufferWrapper.uploaded || bufferWrapper.vertexCount == 0) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java index 2f5478c71..2539c2cf1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/DhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java @@ -50,9 +50,9 @@ import java.util.OptionalInt; * Often used to apply post processing effects or * the DH texture to MC's color texture.

* - * @see McCopyRenderer + * @see BlazeDhCopyRenderer */ -public class DhApplyRenderer +public class BlazeDhApplyRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -93,7 +93,7 @@ public class DhApplyRenderer // constructor // //=============// //region - public DhApplyRenderer( + public BlazeDhApplyRenderer( String name, @Nullable BlendFunction blendFunction, String vertexShaderPath, String fragmentShaderPath @@ -106,7 +106,7 @@ public class DhApplyRenderer new String[0] // no extra uniforms ); } - public DhApplyRenderer( + public BlazeDhApplyRenderer( String name, @Nullable BlendFunction blendFunction, String vertexShaderPath, String fragmentShaderPath, diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java index c8585d3dc..429e8ac21 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/McCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java @@ -29,7 +29,6 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -43,16 +42,16 @@ import java.util.OptionalInt; /** * Blindly copies one texture into another. * - * @see DhApplyRenderer + * @see BlazeDhApplyRenderer */ -public class McCopyRenderer +public class BlazeDhCopyRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McCopyRenderer INSTANCE = new McCopyRenderer(); + public static final BlazeDhCopyRenderer INSTANCE = new BlazeDhCopyRenderer(); private RenderPipeline pipeline; private boolean init = false; @@ -66,7 +65,7 @@ public class McCopyRenderer //=============// //region - private McCopyRenderer() { } + private BlazeDhCopyRenderer() { } private void tryInit() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index 536893254..b1b949ca9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -33,10 +33,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; -import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -192,7 +191,7 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer this.renderFadeToTexture(); - McCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, McLodRenderer.INSTANCE.dhColorTextureWrapper); + BlazeDhCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, McLodRenderer.INSTANCE.dhColorTextureWrapper); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index 148cefde5..76514442d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -40,8 +40,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; -import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; @@ -78,7 +77,7 @@ public class BlazeDhFogRenderer implements IMcFogRenderer public static final BlazeDhFogRenderer INSTANCE = new BlazeDhFogRenderer(); - private DhApplyRenderer applyRenderer; + private BlazeDhApplyRenderer applyRenderer; private RenderPipeline pipeline; private boolean init = false; @@ -109,7 +108,7 @@ public class BlazeDhFogRenderer implements IMcFogRenderer - this.applyRenderer = new DhApplyRenderer( + this.applyRenderer = new BlazeDhApplyRenderer( "fog_apply_to_dh", new BlendFunction(SourceFactor.SRC_ALPHA, DestFactor.ONE_MINUS_SRC_ALPHA, SourceFactor.ONE, DestFactor.ONE_MINUS_SRC_ALPHA), "apply/blaze/vert", "apply/blaze/frag" diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index b13d71935..b10678a9c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -37,8 +37,7 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; -import com.seibel.distanthorizons.common.render.blaze.apply.DhApplyRenderer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; @@ -56,10 +55,8 @@ import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -/** - * Renders a TODO - */ -public class McSsaoRenderer implements IMcSsaoRenderer +/** Renders SSAO to the DH LODs. */ +public class BlazeDhSsaoRenderer implements IMcSsaoRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -68,10 +65,10 @@ public class McSsaoRenderer implements IMcSsaoRenderer private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McSsaoRenderer INSTANCE = new McSsaoRenderer(); + public static final BlazeDhSsaoRenderer INSTANCE = new BlazeDhSsaoRenderer(); - private DhApplyRenderer applyRenderer; + private BlazeDhApplyRenderer applyRenderer; private RenderPipeline pipeline; private boolean init = false; @@ -90,7 +87,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer //=============// //region - private McSsaoRenderer() { } + private BlazeDhSsaoRenderer() { } private void tryInit() { @@ -101,7 +98,7 @@ public class McSsaoRenderer implements IMcSsaoRenderer this.init = true; - this.applyRenderer = new DhApplyRenderer( + this.applyRenderer = new BlazeDhApplyRenderer( "ssao_apply_to_dh", new BlendFunction(SourceFactor.ZERO, DestFactor.SRC_ALPHA, SourceFactor.ZERO, DestFactor.ONE), "apply/blaze/vert", "ssao/blaze/apply", diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java deleted file mode 100644 index 574354191..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazePostProcessUtil.java +++ /dev/null @@ -1,60 +0,0 @@ -package com.seibel.distanthorizons.common.render.blaze.postProcessing; - -import com.mojang.blaze3d.buffers.GpuBuffer; -import com.mojang.blaze3d.buffers.GpuBufferSlice; -import com.mojang.blaze3d.systems.CommandEncoder; -import com.mojang.blaze3d.systems.GpuDevice; -import com.mojang.blaze3d.systems.RenderSystem; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.util.function.Supplier; - -/** - * Contains code that's used by all post-processing effects. - */ -public class BlazePostProcessUtil -{ - - private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); - private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - - // vertices for a full-screen quad - private static final float[] VERTICES = new float[] - { - // PosX,Y, - -1f, -1f, - 1f, -1f, - 1f, 1f, - -1f, 1f, - }; - - - public static GpuBuffer createAndUploadScreenVertexData(String name) - { - Supplier labelSupplier = () -> "distantHorizons:"+name; - - int usage = GpuBuffer.USAGE_COPY_DST - | GpuBuffer.USAGE_VERTEX; - int size = VERTICES.length * Float.BYTES; - GpuBuffer vboGpuBuffer = GPU_DEVICE.createBuffer(labelSupplier, usage, size); - - { - int length = VERTICES.length * Float.BYTES; - GpuBufferSlice bufferSlice = new GpuBufferSlice(vboGpuBuffer, /*offset*/ 0, length); - - ByteBuffer byteBuffer = ByteBuffer.allocateDirect(VERTICES.length * Float.BYTES); - // Fill buffer with vertices. - byteBuffer.order(ByteOrder.nativeOrder()); - byteBuffer.asFloatBuffer().put(VERTICES); - byteBuffer.rewind(); - - COMMAND_ENCODER.writeToBuffer(bufferSlice, byteBuffer); - } - - return vboGpuBuffer; - } - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index 0e13bc59c..235147a24 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/McVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -33,10 +33,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; -import com.seibel.distanthorizons.common.render.blaze.apply.McCopyRenderer; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -57,9 +56,10 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * Renders a TODO + * Fades the vanilla chunks + * into DH's LODs. */ -public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer +public class BlazeVanillaFadeRenderer implements IMcVanillaFadeRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -68,7 +68,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McVanillaFadeRenderer INSTANCE = new McVanillaFadeRenderer(); + public static final BlazeVanillaFadeRenderer INSTANCE = new BlazeVanillaFadeRenderer(); private RenderPipeline pipeline; private boolean init = false; @@ -89,7 +89,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer //=============// //region - private McVanillaFadeRenderer() { } + private BlazeVanillaFadeRenderer() { } private void tryInit() { @@ -220,7 +220,7 @@ public class McVanillaFadeRenderer implements IMcVanillaFadeRenderer this.renderFadeToTexture(); - McCopyRenderer.INSTANCE.render(this.fadeColorTextureWrapper, this.mcColorTextureWrapper); + BlazeDhCopyRenderer.INSTANCE.render(this.fadeColorTextureWrapper, this.mcColorTextureWrapper); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java index 21dc44b89..a86d21719 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/DhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java @@ -47,14 +47,14 @@ import java.util.OptionalInt; * to the center of the screen to confirm DH's * apply shader is running correctly */ -public class DhTestRenderer implements IMcTestRenderer +public class BlazeDhTestRenderer implements IMcTestRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final DhTestRenderer INSTANCE = new DhTestRenderer(); + public static final BlazeDhTestRenderer INSTANCE = new BlazeDhTestRenderer(); private RenderPipeline pipeline; private boolean init = false; @@ -70,7 +70,7 @@ public class DhTestRenderer implements IMcTestRenderer //=============// //region - private DhTestRenderer() { } + private BlazeDhTestRenderer() { } private void tryInit() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java similarity index 92% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java index c4c0f5c76..862d9bc6f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/VertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java @@ -9,7 +9,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWra import java.nio.ByteBuffer; -public class VertexBufferWrapper implements IVertexBufferWrapper +public class BlazeVertexBufferWrapper implements IVertexBufferWrapper { private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); @@ -30,7 +30,7 @@ public class VertexBufferWrapper implements IVertexBufferWrapper //=============// //region - public VertexBufferWrapper(String name) { this.name = name; } + public BlazeVertexBufferWrapper(String name) { this.name = name; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java similarity index 77% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java index ea7017619..91578c52b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/LodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java @@ -3,18 +3,12 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.uniform; import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; -import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; import java.nio.ByteBuffer; -/** - * TODO ?? - */ -public class LodUniformBufferWrapper extends UniformBufferWrapper implements ILodContainerUniformBufferWrapper +public class BlazeLodUniformBufferWrapper extends UniformBufferWrapper implements ILodContainerUniformBufferWrapper { private boolean uploaded = false; @@ -26,7 +20,7 @@ public class LodUniformBufferWrapper extends UniformBufferWrapper implements ILo //=============// //region - public LodUniformBufferWrapper() { super(LodUniformBufferWrapper.class.getName()); } + public BlazeLodUniformBufferWrapper() { super(BlazeLodUniformBufferWrapper.class.getName()); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java index 37b6388c1..fabb3a8ae 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java @@ -5,7 +5,6 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; -import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index ae74fa0e9..b0afbc502 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -23,9 +23,9 @@ import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRendere import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.McSsaoRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.McVanillaFadeRenderer; -import com.seibel.distanthorizons.common.render.blaze.test.DhTestRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanillaFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestRenderer; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; @@ -80,10 +80,10 @@ public class DependencySetup public static void createRenderBindings() { - SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, DhTestRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, McVanillaFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, BlazeDhTestRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, BlazeVanillaFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, McSsaoRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, BlazeDhSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, BlazeDhFogRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 8471bedf6..add474398 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,10 +24,10 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; -import com.seibel.distanthorizons.common.render.blaze.McGenericObjectRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhGenericObjectRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.LodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.VertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; @@ -220,15 +220,15 @@ public class WrapperFactory implements IWrapperFactory @Override - public IVertexBufferWrapper createVboWrapper(String name) { return new VertexBufferWrapper(name); } + public IVertexBufferWrapper createVboWrapper(String name) { return new BlazeVertexBufferWrapper(name); } @Override - public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new LodUniformBufferWrapper(); } + public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new BlazeLodUniformBufferWrapper(); } @Override public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } @Override - public IMcGenericRenderer createGenericRenderer() { return new McGenericObjectRenderer(); } + public IMcGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } //endregion From 71237caa8191b16f40daa4aa228d2a1ff11eba41 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 16:28:57 -0500 Subject: [PATCH 44/72] Start moving OpenGL rendering to common 1 --- .../common/render/nativeGl/DebugRenderer.java | 281 +++++++ .../nativeGl/DhTerrainShaderProgram.java | 227 ++++++ .../common/render/nativeGl/LodRenderer.java | 766 ++++++++++++++++++ .../generic/GenericObjectRenderer.java | 735 +++++++++++++++++ .../generic/GenericObjectShaderProgram.java | 232 ++++++ .../generic/GenericRenderObjectFactory.java | 75 ++ .../NativeGlGenericObjectVertexContainer.java | 180 ++++ .../nativeGl/generic/RenderableBoxGroup.java | 361 +++++++++ .../render/nativeGl/glObject/GLEnums.java | 261 ++++++ .../render/nativeGl/glObject/GLProxy.java | 351 ++++++++ .../render/nativeGl/glObject/GLState.java | 259 ++++++ .../nativeGl/glObject/buffer/GLBuffer.java | 345 ++++++++ .../glObject/buffer/GLElementBuffer.java | 60 ++ .../glObject/buffer/GLVertexBuffer.java | 88 ++ .../glObject/buffer/QuadElementBuffer.java | 192 +++++ .../nativeGl/glObject/shader/Shader.java | 184 +++++ .../glObject/shader/ShaderProgram.java | 225 +++++ .../glObject/texture/DHDepthTexture.java | 62 ++ .../glObject/texture/DhColorTexture.java | 183 +++++ .../glObject/texture/DhFramebuffer.java | 152 ++++ .../texture/EDhDepthBufferFormat.java | 114 +++ .../texture/EDhInternalTextureFormat.java | 130 +++ .../glObject/texture/EDhPixelFormat.java | 60 ++ .../glObject/texture/EDhPixelType.java | 64 ++ .../nativeGl/glObject/texture/EGlVersion.java | 9 + .../AbstractVertexAttribute.java | 92 +++ .../VertexAttributePostGL43.java | 155 ++++ .../VertexAttributePreGL43.java | 253 ++++++ .../vertexAttribute/VertexPointer.java | 72 ++ .../nativeGl/postProcessing/ScreenQuad.java | 96 +++ .../postProcessing/VanillaFadeRenderer.java | 188 +++++ .../postProcessing/apply/DhApplyShader.java | 199 +++++ .../postProcessing/fade/DhFadeRenderer.java | 161 ++++ .../postProcessing/fade/DhFadeShader.java | 165 ++++ .../postProcessing/fade/FadeApplyShader.java | 118 +++ .../fade/VanillaFadeShader.java | 198 +++++ .../postProcessing/fog/FogApplyShader.java | 118 +++ .../postProcessing/fog/FogRenderer.java | 140 ++++ .../postProcessing/fog/FogSettings.java | 72 ++ .../postProcessing/fog/FogShader.java | 287 +++++++ .../postProcessing/ssao/SSAOApplyShader.java | 145 ++++ .../postProcessing/ssao/SSAORenderer.java | 140 ++++ .../postProcessing/ssao/SSAOShader.java | 142 ++++ .../render/nativeGl/test/GlTestRenderer.java | 141 ++++ .../nativeGl/util/AbstractShaderRenderer.java | 77 ++ .../util/vertexFormat/LodVertexFormat.java | 110 +++ .../vertexFormat/LodVertexFormatElement.java | 168 ++++ .../util/vertexFormat/VertexFormats.java | 50 ++ 48 files changed, 8883 insertions(+) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java new file mode 100644 index 000000000..e39876121 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java @@ -0,0 +1,281 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.config.types.ConfigEntry; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.pos.DhSectionPos; +import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcDebugRenderer; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL32; + +import java.awt.*; +import java.lang.ref.WeakReference; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.concurrent.PriorityBlockingQueue; + +/** + * Handles rendering the wireframe particles + * that are used for seeing what the system's doing. + */ +public class DebugRenderer +{ + public static DebugRenderer INSTANCE = new DebugRenderer(); + + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() + .maxCountPerSecond(1) + .build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + + // rendering setup + private ShaderProgram basicShader; + private GLElementBuffer outlineIndexBuffer; + private AbstractVertexAttribute va; + private boolean init = false; + + // used when rendering + private Mat4f dhMvmProjMatrixThisFrame; + private Vec3f camPosFloatThisFrame; + + + private final IMcDebugRenderer.RendererLists rendererLists = new IMcDebugRenderer.RendererLists(); + private final PriorityBlockingQueue particles = new PriorityBlockingQueue<>(); + + + + + /** A box from 0,0,0 to 1,1,1 */ + private static final float[] BOX_VERTICES = { + //region + // Pos x y z + 0, 0, 0, + 1, 0, 0, + 1, 1, 0, + 0, 1, 0, + 0, 0, 1, + 1, 0, 1, + 1, 1, 1, + 0, 1, 1, + //endregion + }; + + private static final int[] BOX_OUTLINE_INDICES = { + //region + 0, 1, + 1, 2, + 2, 3, + 3, 0, + + 4, 5, + 5, 6, + 6, 7, + 7, 4, + + 0, 4, + 1, 5, + 2, 6, + 3, 7, + //endregion + }; + + + + //=============// + // constructor // + //=============// + //region + + private DebugRenderer() { } + + public void init() + { + if (this.init) + { + return; + } + this.init = true; + + this.va = AbstractVertexAttribute.create(); + this.va.bind(); + // Pos + this.va.setVertexAttribute(0, 0, VertexPointer.addVec3Pointer(false)); + this.va.completeAndCheck(Float.BYTES * 3); + this.basicShader = new ShaderProgram( + "shaders/debug/vert.vert", + "shaders/debug/frag.frag", + "vPosition" + ); + this.createBuffer(); + } + + private void createBuffer() + { + // box vertices + ByteBuffer boxVerticesBuffer = ByteBuffer.allocateDirect(BOX_VERTICES.length * Float.BYTES); + boxVerticesBuffer.order(ByteOrder.nativeOrder()); + boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); + boxVerticesBuffer.rewind(); + + + // outline vertex indexes + ByteBuffer boxOutlineBuffer = ByteBuffer.allocateDirect(BOX_OUTLINE_INDICES.length * Integer.BYTES); + boxOutlineBuffer.order(ByteOrder.nativeOrder()); + boxOutlineBuffer.asIntBuffer().put(BOX_OUTLINE_INDICES); + boxOutlineBuffer.rewind(); + this.outlineIndexBuffer = new GLElementBuffer(false); + this.outlineIndexBuffer.uploadBuffer(boxOutlineBuffer, EDhApiGpuUploadMethod.DATA, BOX_OUTLINE_INDICES.length * Integer.BYTES, GL32.GL_STATIC_DRAW); + + } + + //endregion + + + + + + //===========// + // rendering // + //===========// + //region + + public void render(RenderParams renderEventParam) + { + //this.dhMvmProjMatrixThisFrame = dhMvmProjMatrix; // TODO + Vec3d camPos = MC_RENDER.getCameraExactPosition(); + this.camPosFloatThisFrame = new Vec3f((float) camPos.x, (float) camPos.y, (float) camPos.z); + + this.init(); + + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + GLMC.enableDepthTest(); + + this.basicShader.bind(); + this.va.bind(); + + + this.outlineIndexBuffer.bind(); + //this.rendererLists.render(this); // TODO + + + // particle rendering + IMcDebugRenderer.BoxParticle head = null; + while ((head = this.particles.poll()) != null && head.isDead()) + { /* remove dead particles */ } + if (head != null) + { + // re-add the popped off head + this.particles.add(head); + } + + IMcDebugRenderer renderer = SingletonInjector.INSTANCE.get(IMcDebugRenderer.class); + renderer.render(renderEventParam, this.particles); + + } + + @Deprecated // TODO this should add all the boxes to a list so we can render them as a batch instead of individual draw calls + public void renderBox(IMcDebugRenderer.Box box) + { + IMcDebugRenderer renderer = SingletonInjector.INSTANCE.get(IMcDebugRenderer.class); + renderer.render(box); + } + + //public void render(Mat4f dhMvmProjMatrix) + //{ + // this.dhMvmProjMatrixThisFrame = dhMvmProjMatrix; + // Vec3d camPos = MC_RENDER.getCameraExactPosition(); + // this.camPosFloatThisFrame = new Vec3f((float) camPos.x, (float) camPos.y, (float) camPos.z); + // + // this.init(); + // + // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + // GLMC.enableDepthTest(); + // + // this.basicShader.bind(); + // this.va.bind(); + // + // + // this.outlineIndexBuffer.bind(); + // this.rendererLists.render(this); + // + // + // // particle rendering + // BoxParticle head = null; + // while ((head = this.particles.poll()) != null && head.isDead()) + // { /* remove dead particles */ } + // if (head != null) + // { + // // re-add the popped off head + // this.particles.add(head); + // } + // + // + // // box rendering + // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + // for (BoxParticle particle : this.particles) + // { + // // a new box is created each time since the height will be different based on the time it's lived + // this.renderBox(particle.createNewRenderBox()); + // } + //} + // + //public void renderBox(Box box) + //{ + // Mat4f boxTransform = Mat4f.createTranslateMatrix(box.minPos.x - this.camPosFloatThisFrame.x, box.minPos.y - this.camPosFloatThisFrame.y, box.minPos.z - this.camPosFloatThisFrame.z); + // boxTransform.multiply(Mat4f.createScaleMatrix(box.maxPos.x - box.minPos.x, box.maxPos.y - box.minPos.y, box.maxPos.z - box.minPos.z)); + // + // Mat4f transformMatrix = this.dhMvmProjMatrixThisFrame.copy(); + // transformMatrix.multiply(boxTransform); + // this.basicShader.setUniform(this.basicShader.getUniformLocation("uTransform"), transformMatrix); + // + // this.basicShader.setUniform(this.basicShader.getUniformLocation("uColor"), box.color); + // + // GL32.glDrawElements(GL32.GL_LINES, BOX_OUTLINE_INDICES.length, GL32.GL_UNSIGNED_INT, 0); + //} + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java new file mode 100644 index 000000000..81e45c6b0 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -0,0 +1,227 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl; + +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePostGL43; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePreGL43; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat.LodVertexFormat; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; + +/** + * Handles rendering the normal LOD terrain. + * @see LodQuadBuilder + */ +public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShaderProgram +{ + public final AbstractVertexAttribute vao; + + // Uniforms + public int uCombinedMatrix = -1; + public int uModelOffset = -1; + public int uWorldYOffset = -1; + + public int uMircoOffset = -1; + public int uEarthRadius = -1; + public int uLightMap = -1; + + // fragment shader uniforms + public int uClipDistance = -1; + public int uDitherDhRendering = -1; + + // Noise Uniforms + public int uNoiseEnabled = -1; + public int uNoiseSteps = -1; + public int uNoiseIntensity = -1; + public int uNoiseDropoff = -1; + + // Debug Uniform + public int uIsWhiteWorld = -1; + + + + //=============// + // constructor // + //=============// + + // This will bind AbstractVertexAttribute + public DhTerrainShaderProgram() + { + super( + "shaders/standard.vert", + "shaders/flat_shaded.frag", + new String[]{"vPosition", "color"} + ); + + this.uCombinedMatrix = this.getUniformLocation("uCombinedMatrix"); + this.uModelOffset = this.getUniformLocation("uModelOffset"); + this.uWorldYOffset = this.getUniformLocation("uWorldYOffset"); + this.uDitherDhRendering = this.getUniformLocation("uDitherDhRendering"); + this.uMircoOffset = this.getUniformLocation("uMircoOffset"); + this.uEarthRadius = this.getUniformLocation("uEarthRadius"); + + this.uLightMap = this.getUniformLocation("uLightMap"); + + // Fog/Clip Uniforms + this.uClipDistance = this.getUniformLocation("uClipDistance"); + + // Noise Uniforms + this.uNoiseEnabled = this.getUniformLocation("uNoiseEnabled"); + this.uNoiseSteps = this.getUniformLocation("uNoiseSteps"); + this.uNoiseIntensity = this.getUniformLocation("uNoiseIntensity"); + this.uNoiseDropoff = this.getUniformLocation("uNoiseDropoff"); + + // Debug Uniform + this.uIsWhiteWorld = this.getUniformLocation("uIsWhiteWorld"); + + + if (GLProxy.getInstance().vertexAttributeBufferBindingSupported) + { + this.vao = new VertexAttributePostGL43(); // also binds AbstractVertexAttribute + } + else + { + this.vao = new VertexAttributePreGL43(); // also binds AbstractVertexAttribute + } + this.vao.bind(); + + // short: x, y, z, meta + // meta: byte skylight, byte blocklight, byte microOffset + this.vao.setVertexAttribute(0, 0, VertexPointer.addUnsignedShortsPointer(4, false, true)); + // byte: r, g, b, a + this.vao.setVertexAttribute(0, 1, VertexPointer.addUnsignedBytesPointer(4, true, false)); + // byte: iris material ID, normal index, 2 spacers + this.vao.setVertexAttribute(0, 2, VertexPointer.addUnsignedBytesPointer(4, true, true)); + + try + { + int vertexByteCount = LodVertexFormat.DH_VERTEX_FORMAT.getByteSize(); + this.vao.completeAndCheck(vertexByteCount); + } + catch (RuntimeException e) + { + System.out.println(LodVertexFormat.DH_VERTEX_FORMAT); + throw e; + } + + } + + + + //=========// + // methods // + //=========// + + @Override + public void bind() + { + super.bind(); + this.vao.bind(); + } + @Override + public void unbind() + { + super.unbind(); + this.vao.unbind(); + } + + @Override + public void free() + { + this.vao.free(); + super.free(); + } + + @Override + public void bindVertexBuffer(int vbo) { this.vao.bindBufferToAllBindingPoints(vbo); } + + @Override + public void fillUniformData(DhApiRenderParam renderParameters) + { + Mat4f combinedMatrix = new Mat4f(renderParameters.dhProjectionMatrix); + combinedMatrix.multiply(renderParameters.dhModelViewMatrix); + + super.bind(); + + // uniforms + this.setUniform(this.uCombinedMatrix, combinedMatrix); + this.setUniform(this.uMircoOffset, 0.01f); // 0.01 block offset + + this.setUniform(this.uLightMap, LightMapWrapper.GL_BOUND_INDEX); + + this.setUniform(this.uWorldYOffset, (float) renderParameters.worldYOffset); + + this.setUniform(this.uDitherDhRendering, Config.Client.Advanced.Graphics.Quality.ditherDhFade.get()); + + float curveRatio = Config.Client.Advanced.Graphics.Experimental.earthCurveRatio.get(); + if (curveRatio < -1.0f || curveRatio > 1.0f) + { + curveRatio = /*6371KM*/ 6371000.0f / curveRatio; + } + else + { + // disable curvature if the config value is between -1 and 1 + curveRatio = 0.0f; + } + this.setUniform(this.uEarthRadius, curveRatio); + + // Noise Uniforms + this.setUniform(this.uNoiseEnabled, Config.Client.Advanced.Graphics.NoiseTexture.enableNoiseTexture.get()); + this.setUniform(this.uNoiseSteps, Config.Client.Advanced.Graphics.NoiseTexture.noiseSteps.get()); + this.setUniform(this.uNoiseIntensity, Config.Client.Advanced.Graphics.NoiseTexture.noiseIntensity.get()); + this.setUniform(this.uNoiseDropoff, Config.Client.Advanced.Graphics.NoiseTexture.noiseDropoff.get()); + + // Debug + this.setUniform(this.uIsWhiteWorld, Config.Client.Advanced.Debugging.enableWhiteWorld.get()); + + // Clip Uniform + float dhNearClipDistance = RenderUtil.getNearClipPlaneInBlocks(); + if (!Config.Client.Advanced.Debugging.lodOnlyMode.get()) + { + // this added value prevents the near clip plane and discard circle from touching, which looks bad + dhNearClipDistance += 16f; + } + this.setUniform(this.uClipDistance, dhNearClipDistance); + } + + @Override + public void setModelOffsetPos(DhApiVec3f modelOffsetPos) { this.setUniform(this.uModelOffset, new Vec3f(modelOffsetPos)); } + + @Override + public int getId() { return this.id; } + + /** The base DH render program should always render */ + @Override + public boolean overrideThisFrame() { return true; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java new file mode 100644 index 000000000..e9a165109 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java @@ -0,0 +1,766 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl; + +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFadeRenderer; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; +import com.seibel.distanthorizons.core.render.DhApiRenderProxy; +import com.seibel.distanthorizons.core.render.RenderBufferHandler; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog.FogRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao.SSAORenderer; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL32; + +/** + * This is where all the magic happens.
+ * This is where LODs are draw to the world. + */ +public class LodRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .build(); + + public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .maxCountPerSecond(4) + .build(); + + private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); + + public static final LodRenderer INSTANCE = new LodRenderer(); + + + + // these ID's either what any render is currently using (since only one renderer can be active at a time), or just used previously + private int activeFramebufferId = -1; + private int activeColorTextureId = -1; + private int activeDepthTextureId = -1; + private int textureWidth; + private int textureHeight; + + + private IDhApiShaderProgram lodRenderProgram = null; + public QuadElementBuffer quadIBO = null; + private boolean renderObjectsCreated = false; + + // framebuffer and texture ID's for this renderer + private IDhApiFramebuffer framebuffer; + /** will be null if MC's framebuffer is being used since MC already has a color texture */ + @Nullable + private DhColorTexture nullableColorTexture; + private DHDepthTexture depthTexture; + /** + * If true the {@link LodRenderer#framebuffer} is the same as MC's. + * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. + */ + private boolean usingMcFramebuffer = false; + + + + //=============// + // constructor // + //=============// + + private LodRenderer() { } + + + + //===========// + // rendering // + //===========// + //region + + /** + * This will draw both opaque and transparent LODs if + * {@link DhApiRenderProxy#getDeferTransparentRendering()} is false, + * otherwise it will only render opaque LODs. + */ + public void render(RenderParams renderParams, IProfilerWrapper profiler) + { this.renderLodPass(renderParams, profiler, false); } + + /** + * This method is designed for Iris to be able + * to draw water in a deferred rendering context. + * It needs to be updated with any major changes, + * but shouldn't be activated as per deferWaterRendering. + */ + public void renderDeferred(RenderParams renderParams, IProfilerWrapper profiler) + { this.renderLodPass(renderParams, profiler, true); } + + private void renderLodPass(RenderParams renderParams, IProfilerWrapper profiler, boolean runningDeferredPass) + { + //====================// + // validate rendering // + //====================// + + boolean deferTransparentRendering = DhApiRenderProxy.INSTANCE.getDeferTransparentRendering(); + if (runningDeferredPass + && !deferTransparentRendering) + { + return; + } + boolean firstPass = !runningDeferredPass; + + // RenderParams parameter validation should be done before this + if (!renderParams.validationRun) + { + throw new IllegalArgumentException("Render parameters validation"); + } + + RenderBufferHandler renderBufferHandler = renderParams.renderBufferHandler; + IMcGenericRenderer genericRenderer = renderParams.genericRenderer; + ILightMapWrapper lightmap = renderParams.lightmap; + + + + //=================// + // rendering setup // + //=================// + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderSetupEvent.class, renderParams); + profiler.push("LOD GL setup"); + + if (!this.renderObjectsCreated) + { + boolean setupSuccess = this.createRenderObjects(); + if (!setupSuccess) + { + // shouldn't normally happen, but just in case + return; + } + + // only do this once, that way they can still be reverted if desired + if (Config.Client.Advanced.Graphics.overrideVanillaGraphicsSettings.get()) + { + LOGGER.info("Overriding vanilla MC settings to better fit Distant Horizons... This behavior can be disabled in the Distant Horizons config."); + + MC.disableVanillaClouds(); + MC.disableVanillaChunkFadeIn(); + MC.disableFabulousTransparency(); + } + + this.renderObjectsCreated = true; + } + + this.setGLState(renderParams, firstPass); + + lightmap.bind(); + this.quadIBO.bind(); + + if (firstPass) + { + // we only need to sort/cull the LODs during the first frame + profiler.popPush("LOD build render list"); + renderBufferHandler.buildRenderList(renderParams); + } + + IDhApiShaderProgram lodShaderProgram = this.lodRenderProgram; + IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (lodShaderProgramOverride != null && lodShaderProgram.overrideThisFrame()) + { + lodShaderProgram = lodShaderProgramOverride; + } + + + + //===========// + // rendering // + //===========// + + if (!runningDeferredPass) + { + //=========================// + // opaque and non-deferred // + // transparent rendering // + //=========================// + + // opaque LODs + profiler.popPush("LOD Opaque"); + this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ true); + + // custom objects with SSAO + if (Config.Client.Advanced.Graphics.GenericRendering.enableGenericRendering.get()) + { + profiler.popPush("Custom Objects"); + genericRenderer.render(renderParams, profiler, true); + } + + // SSAO + if (Config.Client.Advanced.Graphics.Ssao.enableSsao.get()) + { + profiler.popPush("LOD SSAO"); + SSAORenderer.INSTANCE.render(new Mat4f(renderParams.dhProjectionMatrix), renderParams.partialTicks); + } + + // custom objects without SSAO + if (Config.Client.Advanced.Graphics.GenericRendering.enableGenericRendering.get()) + { + profiler.popPush("Custom Objects"); + genericRenderer.render(renderParams, profiler, false); + } + + // combined pass transparent rendering + if (!deferTransparentRendering + && Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled) + { + profiler.popPush("LOD Transparent"); + this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ false); + } + + // far plane clip fading + if (Config.Client.Advanced.Graphics.Quality.dhFadeFarClipPlane.get() + // the fade shader messes with the GL state in a way Iris doesn't like, + // so skip it if a shader is active + && (IRIS_ACCESSOR == null || !IRIS_ACCESSOR.isShaderPackInUse())) + { + profiler.popPush("Fade Far Clip Fade"); + DhFadeRenderer.INSTANCE.render( + new Mat4f(renderParams.mcModelViewMatrix), new Mat4f(renderParams.mcProjectionMatrix), + renderParams.partialTicks, profiler); + } + + // fog + if (Config.Client.Advanced.Graphics.Fog.enableDhFog.get() + // this is done to fix issues with: underwater fog, blindness effect, etc. + || renderParams.vanillaFogEnabled) + { + profiler.popPush("LOD Fog"); + + Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); + combinedMatrix.multiply(renderParams.dhModelViewMatrix); + + FogRenderer.INSTANCE.render(combinedMatrix, renderParams.partialTicks); + } + + + + //=================// + // debug rendering // + //=================// + + if (Config.Client.Advanced.Debugging.DebugWireframe.enableRendering.get()) + { + profiler.popPush("Debug wireframes"); + + Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); + combinedMatrix.multiply(renderParams.dhModelViewMatrix); + + // Note: this can be very slow if a lot of boxes are being rendered + //DebugRenderer.INSTANCE.render(combinedMatrix); // TODO + } + + + + //===================// + // optifine clean up // + //===================// + + if (this.usingMcFramebuffer) + { + // If MC's framebuffer is being used the depth needs to be cleared to prevent rendering on top of MC. + // This should only happen when Optifine shaders are being used. + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + + + + //=============================// + // Apply to the MC Framebuffer // + //=============================// + + boolean cancelApplyShader = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeApplyShaderRenderEvent.class, renderParams); + if (!cancelApplyShader) + { + profiler.popPush("LOD Apply"); + + // Copy the LOD framebuffer to Minecraft's framebuffer + DhApplyShader.INSTANCE.render(renderParams.partialTicks); + } + } + else + { + //====================// + // deferred rendering // + //====================// + + if (Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled) + { + profiler.popPush("LOD Transparent"); + this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ false); + + + if (Config.Client.Advanced.Graphics.Fog.enableDhFog.get() + // this is done to fix issues with: underwater fog, blindness effect, etc. + || renderParams.vanillaFogEnabled) + { + profiler.popPush("LOD Fog"); + + Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); + combinedMatrix.multiply(renderParams.dhModelViewMatrix); + + FogRenderer.INSTANCE.render(combinedMatrix, renderParams.partialTicks); + } + } + } + + + + //================// + // render cleanup // + //================// + + profiler.popPush("LOD cleanup"); + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderCleanupEvent.class, renderParams); + + lightmap.unbind(); + this.quadIBO.unbind(); + lodShaderProgram.unbind(); + + + // end of internal LOD profiling + profiler.pop(); + } + + //endregion + + + + //=================// + // Setup Functions // + //=================// + //region + + private void setGLState( + DhApiRenderParam renderEventParam, + boolean firstPass) + { + //===================// + // framebuffer setup // + //===================// + + // get the active framebuffer + IDhApiFramebuffer framebuffer = this.framebuffer; + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + if (framebufferOverride != null && framebufferOverride.overrideThisFrame()) + { + framebuffer = framebufferOverride; + } + this.activeFramebufferId = framebuffer.getId(); + framebuffer.bind(); + + + + //==========// + // bindings // + //==========// + + // by default draw everything as triangles + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + + GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); + + GL32.glDisable(GL32.GL_SCISSOR_TEST); + + // Enable depth test and depth mask + GLMC.enableDepthTest(); + GLMC.glDepthFunc(GL32.GL_LESS); + GLMC.enableDepthMask(); + + // This is required for MC versions 1.21.5+ + // due to MC updating the lightmap by changing the viewport size + GL32.glViewport(0, 0, this.textureWidth, this.textureHeight); + + this.lodRenderProgram.bind(); + + + + //==========// + // uniforms // + //==========// + + IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (shaderProgramOverride != null) + { + shaderProgramOverride.fillUniformData(renderEventParam); + } + + this.lodRenderProgram.fillUniformData(renderEventParam); + + + + + //===============// + // texture setup // + //===============// + + // resize the textures if needed + if (MC_RENDER.getTargetFramebufferViewportWidth() != this.textureWidth + || MC_RENDER.getTargetFramebufferViewportHeight() != this.textureHeight) + { + // just resizing the textures doesn't work when Optifine is present, + // so recreate the textures with the new size instead + this.createAndBindTextures(); + } + + + // set the active textures + this.activeDepthTextureId = this.depthTexture.getTextureId(); + + if (this.nullableColorTexture != null) + { + this.activeColorTextureId = this.nullableColorTexture.getTextureId(); + } + else + { + // get MC's color texture + this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + } + + + // needs to be fired after all the textures have been created/bound + boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderEventParam); + if (clearTextures) + { + GL32.glClearDepth(1.0); + + float[] clearColorValues = new float[4]; + GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); + GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); + + if (this.usingMcFramebuffer && framebufferOverride == null) + { + // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, + // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues + framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + + + // don't clear the color texture, that removes the sky + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + else if (firstPass) + { + GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + } + } + + + } + + private boolean createRenderObjects() + { + if (this.renderObjectsCreated) + { + LOGGER.warn("Renderer setup called but it has already completed setup!"); + return false; + } + + // GLProxy should have already been created by this point, but just in case create it now + GLProxy.getInstance(); + + + + LOGGER.info("Setting up renderer"); + this.lodRenderProgram = new DhTerrainShaderProgram(); + + this.quadIBO = new QuadElementBuffer(); + this.quadIBO.reserve(LodBufferContainer.MAX_QUADS_PER_BUFFER); + + + // create or get the frame buffer + if (AbstractOptifineAccessor.optifinePresent()) + { + // use MC/Optifine's default Framebuffer so shaders won't remove the LODs + int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); + this.framebuffer = new DhFramebuffer(currentFramebufferId); + this.usingMcFramebuffer = true; + } + else + { + // normal use case + this.framebuffer = new DhFramebuffer(); + this.usingMcFramebuffer = false; + } + + // create and bind the necessary textures + this.createAndBindTextures(); + + if(this.framebuffer.getStatus() != GL32.GL_FRAMEBUFFER_COMPLETE) + { + // This generally means something wasn't bound, IE missing either the color or depth texture + LOGGER.warn("Framebuffer ["+this.framebuffer.getId()+"] isn't complete."); + return false; + } + + + + LOGGER.info("Renderer setup complete"); + return true; + } + + @SuppressWarnings( "deprecation" ) // done to ignore DhApiColorDepthTextureCreatedEvent + private void createAndBindTextures() + { + int oldWidth = this.textureWidth; + int oldHeight = this.textureHeight; + this.textureWidth = MC_RENDER.getTargetFramebufferViewportWidth(); + this.textureHeight = MC_RENDER.getTargetFramebufferViewportHeight(); + + DhApiTextureCreatedParam textureCreatedParam = new DhApiTextureCreatedParam( + oldWidth, oldHeight, + this.textureWidth, this.textureHeight + ); + + + // DhApiColorDepthTextureCreatedEvent needs to be kept around since old versions of Iris need it + ApiEventInjector.INSTANCE.fireAllEvents(DhApiColorDepthTextureCreatedEvent.class, new DhApiColorDepthTextureCreatedEvent.EventParam(textureCreatedParam)); + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeColorDepthTextureCreatedEvent.class, textureCreatedParam); + + + // also update the framebuffer override if present + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + + + this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); + this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + if (framebufferOverride != null) + { + framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + } + + // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound + if (!this.usingMcFramebuffer) + { + this.nullableColorTexture = DhColorTexture.builder().setDimensions(this.textureWidth, this.textureHeight) + .setInternalFormat(EDhInternalTextureFormat.RGBA8) + .setPixelType(EDhPixelType.UNSIGNED_BYTE) + .setPixelFormat(EDhPixelFormat.RGBA) + .build(); + + this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + if (framebufferOverride != null) + { + framebufferOverride.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + } + } + else + { + this.nullableColorTexture = null; + } + + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterColorDepthTextureCreatedEvent.class, textureCreatedParam); + } + + //endregion + + + + //===============// + // LOD rendering // + //===============// + //region + + private void renderLodPass(IDhApiShaderProgram shaderProgram, RenderBufferHandler lodBufferHandler, RenderParams renderEventParam, boolean opaquePass) + { + //=======================// + // debug wireframe setup // + //=======================// + + boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); + if (renderWireframe) + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + GLMC.disableFaceCulling(); + } + else + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + if (!opaquePass) + { + GLMC.enableBlend(); + GLMC.enableDepthTest(); + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + } + else + { + GLMC.disableBlend(); + } + + + + + //===========// + // rendering // + //===========// + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam); + + if (IRIS_ACCESSOR != null) + { + // done to fix a bug with Iris where face culling isn't properly set or reverted in the MC state manager + // which causes Sodium to render some water chunks with their normal inverted + // https://github.com/IrisShaders/Iris/issues/2582 + // https://github.com/IrisShaders/Iris/blob/1.21.9/common/src/main/java/net/irisshaders/iris/compat/dh/LodRendererEvents.java#L346 + GLMC.enableFaceCulling(); + } + + //if (Config.Client.Advanced.Debugging.rendererMode.get() == EDhApiRendererMode.DEFAULT) + //{ + // // Normal LOD rendering + // + // SortedArraySet lodBufferContainer = lodBufferHandler.getColumnRenderBuffers(); + // if (lodBufferContainer != null) + // { + // for (int lodIndex = 0; lodIndex < lodBufferContainer.size(); lodIndex++) + // { + // LodBufferContainer bufferContainer = lodBufferContainer.get(lodIndex); + // this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, shaderProgram, renderEventParam); + // + // GLVertexBuffer[] vbos = opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent; + // for (int vboIndex = 0; vboIndex < vbos.length; vboIndex++) + // { + // GLVertexBuffer vbo = vbos[vboIndex]; + // if (vbo == null) + // { + // continue; + // } + // + // if (vbo.getVertexCount() == 0) + // { + // continue; + // } + // + // vbo.bind(); + // shaderProgram.bindVertexBuffer(vbo.getId()); + // GL32.glDrawElements( + // GL32.GL_TRIANGLES, + // vbo.getVertexCount(), + // this.quadIBO.getType(), 0); + // vbo.unbind(); + // } + // } + // } + //} + //else + { + // basic quad rendering + + IMcTestRenderer testRenderer = SingletonInjector.INSTANCE.get(IMcTestRenderer.class); + testRenderer.render(); + + //TestRenderer.INSTANCE.render(); + //McTestRenderer.INSTANCE.render(); + } + + + //=========================// + // debug wireframe cleanup // + //=========================// + + if (renderWireframe) + { + // default back to GL_FILL since all other rendering uses it + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + } + + /** + * the MVM offset is needed so LODs can be rendered anywhere in the MC world + * without running into floating point percision loss. + */ + private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelPos = new Vec3f( + (float) (pos.getX() - camPos.x), + (float) (pos.getY() - camPos.y), + (float) (pos.getZ() - camPos.z)); + + shaderProgram.bind(); + shaderProgram.setModelOffsetPos(modelPos); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + } + + //endregion + + + + //===============// + // API functions // + //===============// + //region + + /** @return -1 if no frame buffer has been bound yet */ + public int getActiveFramebufferId() { return this.activeFramebufferId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveColorTextureId() { return this.activeColorTextureId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveDepthTextureId() { return this.activeDepthTextureId; } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java new file mode 100644 index 000000000..4a449ee95 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java @@ -0,0 +1,735 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.generic; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiGenericObjectShaderProgram; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.jar.EPlatform; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.logging.f3.F3Screen; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.ISodiumAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; +import com.seibel.distanthorizons.coreapi.ModInfo; +import org.lwjgl.opengl.ARBInstancedArrays; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL33; +import org.lwjgl.system.MemoryUtil; + +import java.awt.*; +import java.nio.ByteBuffer; +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +/** + * Handles rendering generic groups of {@link DhApiRenderableBox}. + * + * @see IDhApiCustomRenderRegister + * @see DhApiRenderableBox + */ +public class GenericObjectRenderer implements IMcGenericRenderer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final ISodiumAccessor SODIUM = ModAccessorInjector.INSTANCE.get(ISodiumAccessor.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); + + /** + * Can be used to troubleshoot the renderer. + * If enabled several debug objects will render around (0,150,0). + */ + public static final boolean RENDER_DEBUG_OBJECTS = false; + + + // rendering setup + private boolean init = false; + + private IDhApiGenericObjectShaderProgram instancedShaderProgram; + private IDhApiGenericObjectShaderProgram directShaderProgram; + //private GLVertexBuffer boxVertexBuffer; + private GLElementBuffer boxIndexBuffer; + + private boolean instancedRenderingAvailable; + private boolean vertexAttribDivisorSupported; + private boolean instancedArraysSupported; + + + + private final ConcurrentHashMap boxGroupById = new ConcurrentHashMap<>(); + + + + /** A box from 0,0,0 to 1,1,1 */ + private static final float[] BOX_VERTICES = { + //region + // Pos x y z + + // min X, vertical face + 0, 0, 0, + 1, 0, 0, + 1, 1, 0, + 0, 1, 0, + // max X, vertical face + 0, 1, 1, + 1, 1, 1, + 1, 0, 1, + 0, 0, 1, + + // min Z, vertical face + 0, 0, 1, + 0, 0, 0, + 0, 1, 0, + 0, 1, 1, + // max Z, vertical face + 1, 0, 1, + 1, 1, 1, + 1, 1, 0, + 1, 0, 0, + + // min Y, horizontal face + 0, 0, 1, + 1, 0, 1, + 1, 0, 0, + 0, 0, 0, + // max Y, horizontal face + 0, 1, 1, + 1, 1, 1, + 1, 1, 0, + 0, 1, 0, + //endregion + }; + + + private static final int[] BOX_INDICES = { + //region + // min X, vertical face + 2, 1, 0, + 0, 3, 2, + // max X, vertical face + 6, 5, 4, + 4, 7, 6, + + // min Z, vertical face + 10, 9, 8, + 8, 11, 10, + // max Z, vertical face + 14, 13, 12, + 12, 15, 14, + + // min Y, horizontal face + 18, 17, 16, + 16, 19, 18, + // max Y, horizontal face + 20, 21, 22, + 22, 23, 20, + //endregion + }; + + + + //=============// + // constructor // + //=============// + //region + + public GenericObjectRenderer() { } + + public void init() + { + if (this.init) + { + return; + } + this.init = true; + + + + //===================================// + // is instanced rendering available? // + //===================================// + + this.vertexAttribDivisorSupported = GLProxy.getInstance().vertexAttribDivisorSupported; + this.instancedArraysSupported = GLProxy.getInstance().instancedArraysSupported; + boolean isMac = (EPlatform.get() == EPlatform.MACOS); + this.instancedRenderingAvailable = (this.vertexAttribDivisorSupported || this.instancedArraysSupported) && !isMac; + if (!this.instancedRenderingAvailable) + { + LOGGER.warn("Instanced rendering not supported by this GPU, falling back to direct rendering. Generic object rendering will be slow and some effects may be disabled."); + } + + + + //======================// + // startup the renderer // + //======================// + + this.instancedShaderProgram = new GenericObjectShaderProgram(true); + this.directShaderProgram = new GenericObjectShaderProgram(false); + + this.createBuffers(); + + if (RENDER_DEBUG_OBJECTS) + { + this.addGenericDebugObjects(); + } + } + private void createBuffers() + { + // box vertices + ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); + boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); + boxVerticesBuffer.rewind(); + //this.boxVertexBuffer = new GLVertexBuffer(false); + //this.boxVertexBuffer.bind(); + //this.boxVertexBuffer.uploadBuffer(boxVerticesBuffer, 8, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES); + MemoryUtil.memFree(boxVerticesBuffer); + + // box vertex indexes + ByteBuffer solidIndexBuffer = MemoryUtil.memAlloc(BOX_INDICES.length * Integer.BYTES); + solidIndexBuffer.asIntBuffer().put(BOX_INDICES); + solidIndexBuffer.rewind(); + this.boxIndexBuffer = new GLElementBuffer(false); + this.boxIndexBuffer.uploadBuffer(solidIndexBuffer, EDhApiGpuUploadMethod.DATA, BOX_INDICES.length * Integer.BYTES, GL32.GL_STATIC_DRAW); + this.boxIndexBuffer.bind(); + MemoryUtil.memFree(solidIndexBuffer); + } + private void addGenericDebugObjects() + { + GenericRenderObjectFactory factory = GenericRenderObjectFactory.INSTANCE; + + + // single giant box + IDhApiRenderableBoxGroup singleGiantBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":CyanChunkBox", + new DhApiRenderableBox( + new DhApiVec3d(0,0,0), new DhApiVec3d(16,190,16), + new Color(Color.CYAN.getRed(), Color.CYAN.getGreen(), Color.CYAN.getBlue(), 125), + EDhApiBlockMaterial.WATER) + ); + singleGiantBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleGiantBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleGiantBoxGroup); + + + // single slender box + IDhApiRenderableBoxGroup singleTallBoxGroup = factory.createForSingleBox( + ModInfo.NAME + ":GreenBeacon", + new DhApiRenderableBox( + new DhApiVec3d(16,0,31), new DhApiVec3d(17,2000,32), + new Color(Color.GREEN.getRed(), Color.GREEN.getGreen(), Color.GREEN.getBlue(), 125), + EDhApiBlockMaterial.ILLUMINATED) + ); + singleTallBoxGroup.setSkyLight(LodUtil.MAX_MC_LIGHT); + singleTallBoxGroup.setBlockLight(LodUtil.MAX_MC_LIGHT); + this.add(singleTallBoxGroup); + + + // absolute box group + ArrayList absBoxList = new ArrayList<>(); + for (int i = 0; i < 18; i++) + { + absBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(i,150+i,24), new DhApiVec3d(1+i,151+i,25), + new Color(Color.ORANGE.getRed(), Color.ORANGE.getGreen(), Color.ORANGE.getBlue()), + EDhApiBlockMaterial.LAVA + ) + ); + } + IDhApiRenderableBoxGroup absolutePosBoxGroup = factory.createAbsolutePositionedGroup(ModInfo.NAME + ":OrangeStairs", absBoxList); + this.add(absolutePosBoxGroup); + + + // relative box group + ArrayList relBoxList = new ArrayList<>(); + for (int i = 0; i < 8; i+=2) + { + relBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(0,i,0), new DhApiVec3d(1,1+i,1), + new Color(Color.MAGENTA.getRed(), Color.MAGENTA.getGreen(), Color.MAGENTA.getBlue()), + EDhApiBlockMaterial.METAL + ) + ); + } + IDhApiRenderableBoxGroup relativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MovingMagentaGroup", + new DhApiVec3d(24, 140, 24), + relBoxList); + relativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d pos = relativePosBoxGroup.getOriginBlockPos(); + pos.x += event.partialTicks / 2; + pos.x %= 32; + relativePosBoxGroup.setOriginBlockPos(pos); + }); + this.add(relativePosBoxGroup); + + + // massive relative box group + ArrayList massRelBoxList = new ArrayList<>(); + for (int x = 0; x < 50*2; x+=2) + { + for (int z = 0; z < 50*2; z+=2) + { + massRelBoxList.add(new DhApiRenderableBox( + new DhApiVec3d(-x, 0, -z), new DhApiVec3d(1-x, 1, 1-z), + new Color(Color.RED.getRed(), Color.RED.getGreen(), Color.RED.getBlue()), + EDhApiBlockMaterial.TERRACOTTA + ) + ); + } + } + IDhApiRenderableBoxGroup massRelativePosBoxGroup = factory.createRelativePositionedGroup( + ModInfo.NAME + ":MassRedGroup", + new DhApiVec3d(-25, 140, 0), + massRelBoxList); + massRelativePosBoxGroup.setPreRenderFunc((event) -> + { + DhApiVec3d blockPos = massRelativePosBoxGroup.getOriginBlockPos(); + blockPos.y += event.partialTicks / 4; + if (blockPos.y > 150f) + { + blockPos.y = 140f; + + Color newColor = (massRelativePosBoxGroup.get(0).color == Color.RED) ? Color.RED.darker() : Color.RED; + massRelativePosBoxGroup.forEach((box) -> { box.color = newColor; }); + massRelativePosBoxGroup.triggerBoxChange(); + } + + massRelativePosBoxGroup.setOriginBlockPos(blockPos); + }); + this.add(massRelativePosBoxGroup); + } + + //endregion + + + + //==============// + // registration // + //==============// + //region + + @Override + public void add(IDhApiRenderableBoxGroup iBoxGroup) throws IllegalArgumentException + { + if (!(iBoxGroup instanceof RenderableBoxGroup)) + { + throw new IllegalArgumentException("Box group must be of type ["+ RenderableBoxGroup.class.getSimpleName()+"], type received: ["+(iBoxGroup != null ? iBoxGroup.getClass() : "NULL")+"]."); + } + RenderableBoxGroup boxGroup = (RenderableBoxGroup) iBoxGroup; + + + long id = boxGroup.getId(); + if (this.boxGroupById.containsKey(id)) + { + throw new IllegalArgumentException("A box group with the ID [" + id + "] is already present."); + } + + this.boxGroupById.put(id, boxGroup); + } + + @Override + public IDhApiRenderableBoxGroup remove(long id) { return this.boxGroupById.remove(id); } + + public void clear() { this.boxGroupById.clear(); } + + //endregion + + + + //===========// + // rendering // + //===========// + //region + + /** + * @param renderingWithSsao + * if true that means this render call is happening before the SSAO pass + * and any objects rendered in this pass will have SSAO applied to them. + */ + @Override + public void render(RenderParams renderEventParam, IProfilerWrapper profiler, boolean renderingWithSsao) + { + // render setup // + profiler.push("setup"); + + this.init(); + + boolean useInstancedRendering = this.instancedRenderingAvailable + && Config.Client.Advanced.Graphics.GenericRendering.enableInstancedRendering.get(); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderSetupEvent.class, renderEventParam); + + + boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); + if (renderWireframe) + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + GLMC.disableFaceCulling(); + } + else + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + GLMC.enableBlend(); + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + + IDhApiGenericObjectShaderProgram shaderProgram = useInstancedRendering ? this.instancedShaderProgram : this.directShaderProgram; + IDhApiGenericObjectShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiGenericObjectShaderProgram.class); + if (shaderProgramOverride != null && shaderProgram.overrideThisFrame()) + { + shaderProgram = shaderProgramOverride; + } + + shaderProgram.bind(renderEventParam); + //shaderProgram.bindVertexBuffer(this.boxVertexBuffer.getId()); + + this.boxIndexBuffer.bind(); + + Vec3d camPos = MC_RENDER.getCameraExactPosition(); + + + + // rendering // + + Collection boxList = this.boxGroupById.values(); + for (RenderableBoxGroup boxGroup : boxList) + { + // validation // + + // shouldn't happen, but just in case + if (boxGroup == null) + { + continue; + } + + // skip boxes that shouldn't render this pass + if (boxGroup.ssaoEnabled != renderingWithSsao) + { + continue; + } + + profiler.popPush("render prep"); + boxGroup.preRender(renderEventParam); // called even if the group is inactive, so the group can be activate if desired + + // ignore inactive groups + if (!boxGroup.active) + { + continue; + } + + // allow API users to cancel this object's rendering + boolean cancelRendering = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericObjectRenderEvent.class, new DhApiBeforeGenericObjectRenderEvent.EventParam(renderEventParam, boxGroup)); + if (cancelRendering) + { + continue; + } + + // update instanced data if needed + if (useInstancedRendering) + { + boxGroup.tryUpdateInstancedDataAsync(); + + // skip groups that haven't been uploaded yet + if (boxGroup.vertexBufferContainer.getState() != NativeGlGenericObjectVertexContainer.EState.RENDER) + { + continue; + } + } + + + + // render // + + profiler.popPush("rendering"); + profiler.push(boxGroup.getResourceLocationNamespace()); + profiler.push(boxGroup.getResourceLocationPath()); + if (useInstancedRendering) + { + this.renderBoxGroupInstanced(shaderProgram, renderEventParam, boxGroup, camPos, profiler); + } + else + { + this.renderBoxGroupDirect(shaderProgram, renderEventParam, boxGroup, camPos, profiler); + } + profiler.pop(); // resource path + profiler.pop(); // resource namespace + + boxGroup.postRender(renderEventParam); + } + + + //==========// + // clean up // + //==========// + + profiler.popPush("cleanup"); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeGenericRenderCleanupEvent.class, renderEventParam); + + if (renderWireframe) + { + // default back to GL_FILL since all other rendering uses it + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + shaderProgram.unbind(); + + profiler.pop(); + } + + //endregion + + + + //=====================// + // instanced rendering // + //=====================// + //region + + private void renderBoxGroupInstanced( + IDhApiGenericObjectShaderProgram shaderProgram, DhApiRenderParam renderEventParam, + RenderableBoxGroup boxGroup, Vec3d camPos, + IProfilerWrapper profiler) + { + // update instance data // + + profiler.push("vertex setup"); + + DhApiRenderableBoxGroupShading shading = boxGroup.shading; + if (shading == null) + { + shading = DEFAULT_SHADING; + } + + shaderProgram.fillIndirectUniformData( + renderEventParam, + shading, boxGroup, + camPos); + + + + // Bind instance data // + profiler.popPush("binding"); + + NativeGlGenericObjectVertexContainer container = (NativeGlGenericObjectVertexContainer)(boxGroup.vertexBufferContainer); + + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.color); + GL32.glEnableVertexAttribArray(1); + GL32.glVertexAttribPointer(1, 4, GL32.GL_FLOAT, false, 4 * Float.BYTES, 0); + this.vertexAttribDivisor(1, 1); + + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.scale); + GL32.glEnableVertexAttribArray(2); + this.vertexAttribDivisor(2, 1); + GL32.glVertexAttribPointer(2, 3, GL32.GL_FLOAT, false, 3 * Float.BYTES, 0); + + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.chunkPos); + GL32.glEnableVertexAttribArray(3); + this.vertexAttribDivisor(3, 1); + GL32.glVertexAttribIPointer(3, 3, GL32.GL_INT, 3 * Integer.BYTES, 0); + + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.subChunkPos); + GL32.glEnableVertexAttribArray(4); + this.vertexAttribDivisor(4, 1); + GL32.glVertexAttribPointer(4, 3, GL32.GL_FLOAT, false, 3 * Float.BYTES, 0); + + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.material); + GL32.glEnableVertexAttribArray(5); + this.vertexAttribDivisor(5, 1); + GL32.glVertexAttribIPointer(5, 1, GL32.GL_BYTE, Byte.BYTES, 0); + + + // Draw instanced + profiler.popPush("render"); + if (container.uploadedBoxCount > 0) + { + GL32.glDrawElementsInstanced(GL32.GL_TRIANGLES, BOX_INDICES.length, GL32.GL_UNSIGNED_INT, 0, container.uploadedBoxCount); + } + + + // Clean up + profiler.popPush("cleanup"); + + GL32.glDisableVertexAttribArray(1); + GL32.glDisableVertexAttribArray(2); + GL32.glDisableVertexAttribArray(3); + GL32.glDisableVertexAttribArray(4); + GL32.glDisableVertexAttribArray(5); + + profiler.pop(); + } + /** + * Clean way to handle both {@link GL33#glVertexAttribDivisor} and {@link ARBInstancedArrays#glVertexAttribDivisorARB} + * based on which one is supported. + */ + private void vertexAttribDivisor(int index, int divisor) + { + if (this.vertexAttribDivisorSupported) + { + GL33.glVertexAttribDivisor(index, divisor); + } + else if(this.instancedArraysSupported) + { + ARBInstancedArrays.glVertexAttribDivisorARB(index, divisor); + } + else + { + throw new IllegalStateException("Instanced rendering isn't supported by this machine. Direct rendering should have been used instead."); + } + } + + //endregion + + + + //==================// + // direct rendering // + //==================// + //region + + private void renderBoxGroupDirect( + IDhApiGenericObjectShaderProgram shaderProgram, + DhApiRenderParam renderEventParam, + RenderableBoxGroup boxGroup, Vec3d camPos, + IProfilerWrapper profiler) + { + profiler.popPush("shared uniforms"); + DhApiRenderableBoxGroupShading shading = boxGroup.shading; + if (shading == null) + { + shading = DhApiRenderableBoxGroupShading.getUnshaded(); + } + + shaderProgram.fillSharedDirectUniformData(renderEventParam, shading, boxGroup, camPos); + + for (int i = 0; i < boxGroup.size(); i++) + { + try + { + DhApiRenderableBox box = boxGroup.get(i); + if (box != null) + { + profiler.popPush("direct uniforms"); + shaderProgram.fillDirectUniformData(renderEventParam, boxGroup, box, camPos); + + profiler.popPush("render"); + GL32.glDrawElements(GL32.GL_TRIANGLES, BOX_INDICES.length, GL32.GL_UNSIGNED_INT, 0); + } + } + catch (IndexOutOfBoundsException e) + { + // Concurrency issue, the list was modified while rendering + // this can probably be ignored. + // However, if it does become a problem we can add locks to the box group. + break; + } + } + + profiler.pop(); + } + + //endregion + + + + //=========// + // getters // + //=========// + //region + + /** @throws IllegalStateException if {@link #init()} function hasn't been called yet */ + public boolean getInstancedRenderingAvailable() throws IllegalStateException + { + if (!this.init) + { + throw new IllegalStateException("GL initialization hasn't been completed."); + } + + return this.instancedRenderingAvailable; + } + + //endregion + + + + //=========// + // F3 menu // + //=========// + //region + + public String getVboRenderDebugMenuString() + { + // get counts + int totalGroupCount = this.boxGroupById.size(); + int totalBoxCount = 0; + + int activeGroupCount = 0; + int activeBoxCount = 0; + + for (long key : this.boxGroupById.keySet()) + { + RenderableBoxGroup renderGroup = this.boxGroupById.get(key); + if (renderGroup.active) + { + activeGroupCount++; + activeBoxCount += renderGroup.size(); + } + totalBoxCount += renderGroup.size(); + } + + + return "Generic Obj #: " + F3Screen.NUMBER_FORMAT.format(activeGroupCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalGroupCount) + ", " + + "Cube #: " + F3Screen.NUMBER_FORMAT.format(activeBoxCount) + "/" + F3Screen.NUMBER_FORMAT.format(totalBoxCount); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java new file mode 100644 index 000000000..8635e7554 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java @@ -0,0 +1,232 @@ +package com.seibel.distanthorizons.common.render.nativeGl.generic; + +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiGenericObjectShaderProgram; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3i; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; + +public class GenericObjectShaderProgram extends ShaderProgram implements IDhApiGenericObjectShaderProgram +{ + public static final String VERTEX_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/vert.vert"; + public static final String VERTEX_SHADER_DIRECT_PATH = "shaders/genericObject/direct/vert.vert"; + public static final String FRAGMENT_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/frag.frag"; + public static final String FRAGMENT_SHADER_DIRECT_PATH = "shaders/genericObject/direct/frag.frag"; + + public final AbstractVertexAttribute va; + + + // shader uniforms + private final int directShaderTransformUniform; + private final int directShaderColorUniform; + + private final int instancedShaderOffsetChunkUniform; + private final int instancedShaderOffsetSubChunkUniform; + private final int instancedShaderCameraChunkPosUniform; + private final int instancedShaderCameraSubChunkPosUniform; + private final int instancedShaderProjectionModelViewMatrixUniform; + + private final int lightMapUniform; + private final int skyLightUniform; + private final int blockLightUniform; + + private final int northShadingUniform; + private final int southShadingUniform; + private final int eastShadingUniform; + private final int westShadingUniform; + private final int topShadingUniform; + private final int bottomShadingUniform; + + + + //=============// + // constructor // + //=============// + + public GenericObjectShaderProgram(boolean useInstancedRendering) + { + super( + useInstancedRendering ? VERTEX_SHADER_INSTANCED_PATH : VERTEX_SHADER_DIRECT_PATH, + useInstancedRendering ? FRAGMENT_SHADER_INSTANCED_PATH : FRAGMENT_SHADER_DIRECT_PATH, + "vPosition" + ); + + this.va = AbstractVertexAttribute.create(); + this.va.bind(); + // Pos + this.va.setVertexAttribute(0, 0, VertexPointer.addVec3Pointer(false)); + this.va.completeAndCheck(Float.BYTES * 3); + + this.directShaderTransformUniform = this.tryGetUniformLocation("uTransform"); + this.directShaderColorUniform = this.tryGetUniformLocation("uColor"); + + this.instancedShaderOffsetChunkUniform = this.tryGetUniformLocation("uOffsetChunk"); + this.instancedShaderOffsetSubChunkUniform = this.tryGetUniformLocation("uOffsetSubChunk"); + this.instancedShaderCameraChunkPosUniform = this.tryGetUniformLocation("uCameraPosChunk"); + this.instancedShaderCameraSubChunkPosUniform = this.tryGetUniformLocation("uCameraPosSubChunk"); + this.instancedShaderProjectionModelViewMatrixUniform = this.tryGetUniformLocation("uProjectionMvm"); + + this.lightMapUniform = this.getUniformLocation("uLightMap"); + this.skyLightUniform = this.getUniformLocation("uSkyLight"); + this.blockLightUniform = this.getUniformLocation("uBlockLight"); + this.northShadingUniform = this.getUniformLocation("uNorthShading"); + this.southShadingUniform = this.getUniformLocation("uSouthShading"); + this.eastShadingUniform = this.getUniformLocation("uEastShading"); + this.westShadingUniform = this.getUniformLocation("uWestShading"); + this.topShadingUniform = this.getUniformLocation("uTopShading"); + this.bottomShadingUniform = this.getUniformLocation("uBottomShading"); + + } + + + + //=========// + // methods // + //=========// + + @Override + public void bind(DhApiRenderParam renderEventParam) + { + super.bind(); + this.va.bind(); + } + @Override + public void unbind() + { + super.unbind(); + this.va.unbind(); + } + + @Override + public void free() + { + this.va.free(); + super.free(); + } + + @Override + public void bindVertexBuffer(int vbo) { this.va.bindBufferToAllBindingPoints(vbo); } + + @Override + public void fillIndirectUniformData( + DhApiRenderParam renderParameters, + DhApiRenderableBoxGroupShading shading, IDhApiRenderableBoxGroup boxGroup, + DhApiVec3d camPos + ) + { + Mat4f projectionMvmMatrix = new Mat4f(renderParameters.dhProjectionMatrix); + projectionMvmMatrix.multiply(renderParameters.dhModelViewMatrix); + + super.bind(); + + + + + this.setUniform(this.instancedShaderOffsetChunkUniform, + new DhApiVec3i( + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + )); + this.setUniform(this.instancedShaderOffsetSubChunkUniform, + new Vec3f( + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().x), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().y), + LodUtil.getSubChunkPosFromDouble(boxGroup.getOriginBlockPos().z) + )); + + this.setUniform(this.instancedShaderCameraChunkPosUniform, + new DhApiVec3i( + LodUtil.getChunkPosFromDouble(camPos.x), + LodUtil.getChunkPosFromDouble(camPos.y), + LodUtil.getChunkPosFromDouble(camPos.z) + )); + this.setUniform(this.instancedShaderCameraSubChunkPosUniform, + new Vec3f( + LodUtil.getSubChunkPosFromDouble(camPos.x), + LodUtil.getSubChunkPosFromDouble(camPos.y), + LodUtil.getSubChunkPosFromDouble(camPos.z) + )); + + this.setUniform(this.instancedShaderProjectionModelViewMatrixUniform, projectionMvmMatrix); + + this.setUniform(this.lightMapUniform, LightMapWrapper.GL_BOUND_INDEX); + this.setUniform(this.skyLightUniform, boxGroup.getSkyLight()); + this.setUniform(this.blockLightUniform, boxGroup.getBlockLight()); + + + this.setUniform(this.northShadingUniform, shading.north); + this.setUniform(this.southShadingUniform, shading.south); + this.setUniform(this.eastShadingUniform, shading.east); + this.setUniform(this.westShadingUniform, shading.west); + this.setUniform(this.topShadingUniform, shading.top); + this.setUniform(this.bottomShadingUniform, shading.bottom); + + + } + + + @Override + public void fillSharedDirectUniformData( + DhApiRenderParam renderParameters, + DhApiRenderableBoxGroupShading shading, IDhApiRenderableBoxGroup boxGroup, + DhApiVec3d camPos) + { + + this.setUniform(this.lightMapUniform, LightMapWrapper.GL_BOUND_INDEX); + this.setUniform(this.skyLightUniform, boxGroup.getSkyLight()); + this.setUniform(this.blockLightUniform, boxGroup.getBlockLight()); + + + this.setUniform(this.northShadingUniform, shading.north); + this.setUniform(this.southShadingUniform, shading.south); + this.setUniform(this.eastShadingUniform, shading.east); + this.setUniform(this.westShadingUniform, shading.west); + this.setUniform(this.topShadingUniform, shading.top); + this.setUniform(this.bottomShadingUniform, shading.bottom); + + } + + public void fillDirectUniformData( + DhApiRenderParam renderParameters, + IDhApiRenderableBoxGroup boxGroup, DhApiRenderableBox box, + DhApiVec3d camPos) + { + Mat4f projectionMvmMatrix = new Mat4f(renderParameters.dhProjectionMatrix); + projectionMvmMatrix.multiply(renderParameters.dhModelViewMatrix); + + Mat4f boxTransform = Mat4f.createTranslateMatrix( + (float) (box.minPos.x + boxGroup.getOriginBlockPos().x - camPos.x), + (float) (box.minPos.y + boxGroup.getOriginBlockPos().y - camPos.y), + (float) (box.minPos.z + boxGroup.getOriginBlockPos().z - camPos.z)); + boxTransform.multiply(Mat4f.createScaleMatrix( + (float) (box.maxPos.x - box.minPos.x), + (float) (box.maxPos.y - box.minPos.y), + (float) (box.maxPos.z - box.minPos.z))); + projectionMvmMatrix.multiply(boxTransform); + this.setUniform(this.directShaderTransformUniform, projectionMvmMatrix); + + this.setUniform(this.directShaderColorUniform, box.color); + + } + + + + @Override + public int getId() { return this.id; } + + /** The base DH render program should always render */ + @Override + public boolean overrideThisFrame() { return true; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java new file mode 100644 index 000000000..7eb2dbb36 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java @@ -0,0 +1,75 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.generic; + +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.logging.DhLogger; + +import java.util.List; +import java.util.*; + +/** + * Handles creating {@link DhApiRenderableBox}. + * + * @see IDhApiCustomRenderRegister + * @see DhApiRenderableBox + */ +public class GenericRenderObjectFactory implements IDhApiCustomRenderObjectFactory +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + public static final GenericRenderObjectFactory INSTANCE = new GenericRenderObjectFactory(); + + + + //=============// + // constructor // + //=============// + + private GenericRenderObjectFactory() { } + + + + //================// + // group creation // + //================// + + @Override + public IDhApiRenderableBoxGroup createForSingleBox(String resourceLocation, DhApiRenderableBox box) + { + ArrayList list = new ArrayList<>(); + list.add(box); + return this.createAbsolutePositionedGroup(resourceLocation, list); + } + + @Override + public IDhApiRenderableBoxGroup createRelativePositionedGroup(String resourceLocation, DhApiVec3d originBlockPos, List boxList) + { return new RenderableBoxGroup(resourceLocation, new DhApiVec3d(originBlockPos.x, originBlockPos.y, originBlockPos.z), boxList, true); } + + @Override + public IDhApiRenderableBoxGroup createAbsolutePositionedGroup(String resourceLocation, List boxList) + { return new RenderableBoxGroup(resourceLocation, new DhApiVec3d(0, 0, 0), boxList, false); } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java new file mode 100644 index 000000000..87ec6eb80 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java @@ -0,0 +1,180 @@ +package com.seibel.distanthorizons.common.render.nativeGl.generic; + +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import org.lwjgl.opengl.GL32; + +import java.awt.*; +import java.util.List; + +/** + * For use by {@link RenderableBoxGroup} + * + * @see RenderableBoxGroup + */ +public class NativeGlGenericObjectVertexContainer implements IGenericObjectVertexBufferContainer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + + public int chunkPos = 0; + public int subChunkPos = 0; + public int scale = 0; + public int color = 0; + public int material = 0; + + public int[] chunkPosData = new int[0]; + public float[] subChunkPosData = new float[0]; + public float[] scalingData = new float[0]; + public float[] colorData = new float[0]; + public int[] materialData = new int[0]; + + public int uploadedBoxCount = 0; + + private EState state = EState.NEW; + @Override + public EState getState() { return this.state; } + @Override + public void setState(EState state) { this.state = state; } + + + + //===========================// + // render building/uploading // + //===========================// + //region + + /** needs to be done on the render thread */ + public void tryRunRenderThreadSetup() + { + if (this.chunkPos == 0) + { + this.chunkPos = GLMC.glGenBuffers(); + this.subChunkPos = GLMC.glGenBuffers(); + this.scale = GLMC.glGenBuffers(); + this.color = GLMC.glGenBuffers(); + this.material = GLMC.glGenBuffers(); + } + } + + public void updateVertexData(List uploadBoxList) + { + int boxCount = uploadBoxList.size(); + + + // recreate the data arrays if their size is different + if (this.uploadedBoxCount != boxCount) + { + this.uploadedBoxCount = boxCount; + + this.chunkPosData = new int[boxCount * 3]; // 3 elements XYZ + this.subChunkPosData = new float[boxCount * 3]; // 3 elements XYZ + this.scalingData = new float[boxCount * 3]; // 3 elements XYZ + + this.colorData = new float[boxCount * 4]; // 4 elements, RGBA + this.materialData = new int[boxCount]; + } + + + // transformation / scaling // + for (int i = 0; i < boxCount; i++) + { + DhApiRenderableBox box = uploadBoxList.get(i); + + int dataIndex = i * 3; + + this.chunkPosData[dataIndex] = LodUtil.getChunkPosFromDouble(box.minPos.x); + this.chunkPosData[dataIndex + 1] = LodUtil.getChunkPosFromDouble(box.minPos.y); + this.chunkPosData[dataIndex + 2] = LodUtil.getChunkPosFromDouble(box.minPos.z); + + this.subChunkPosData[dataIndex] = LodUtil.getSubChunkPosFromDouble(box.minPos.x); + this.subChunkPosData[dataIndex + 1] = LodUtil.getSubChunkPosFromDouble(box.minPos.y); + this.subChunkPosData[dataIndex + 2] = LodUtil.getSubChunkPosFromDouble(box.minPos.z); + + this.scalingData[dataIndex] = (float) (box.maxPos.x - box.minPos.x); + this.scalingData[dataIndex + 1] = (float) (box.maxPos.y - box.minPos.y); + this.scalingData[dataIndex + 2] = (float) (box.maxPos.z - box.minPos.z); + } + + + // colors/materials // + for (int i = 0; i < boxCount; i++) + { + DhApiRenderableBox box = uploadBoxList.get(i); + Color color = box.color; + int colorIndex = i * 4; + this.colorData[colorIndex] = color.getRed() / 255.0f; + this.colorData[colorIndex + 1] = color.getGreen() / 255.0f; + this.colorData[colorIndex + 2] = color.getBlue() / 255.0f; + this.colorData[colorIndex + 3] = color.getAlpha() / 255.0f; + + this.materialData[i] = box.material; + } + + this.state = NativeGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD; + } + + public void uploadDataToGpu() + { + // Upload transformation matrices + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.chunkPos); + GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.chunkPosData, GL32.GL_DYNAMIC_DRAW); + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.subChunkPos); + GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.subChunkPosData, GL32.GL_DYNAMIC_DRAW); + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.scale); + GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.scalingData, GL32.GL_DYNAMIC_DRAW); + + // Upload colors + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.color); + GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.colorData, GL32.GL_DYNAMIC_DRAW); + + // Upload materials + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.material); + GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.materialData, GL32.GL_DYNAMIC_DRAW); + + this.state = EState.RENDER; + } + + //endregion + + + + //================// + // base overrides // + //================// + //region + + @Override + public void close() + { + tryDeleteBuffer(this.chunkPos); + tryDeleteBuffer(this.subChunkPos); + tryDeleteBuffer(this.scale); + tryDeleteBuffer(this.color); + tryDeleteBuffer(this.material); + } + private static void tryDeleteBuffer(int bufferId) + { + // usually unnecessary, but just in case + if (bufferId != 0) + { + GLMC.glDeleteBuffers(bufferId); + } + } + + //endregion + + + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java new file mode 100644 index 000000000..2e354598e --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java @@ -0,0 +1,361 @@ +package com.seibel.distanthorizons.common.render.nativeGl.generic; + +import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; +import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker; +import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import org.jetbrains.annotations.Nullable; + +import java.io.Closeable; +import java.util.*; +import java.util.List; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Consumer; +import java.util.function.Predicate; +import java.util.function.UnaryOperator; +import java.util.stream.Stream; + +public class RenderableBoxGroup + extends AbstractList + implements IDhApiRenderableBoxGroup, Closeable +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class); + + public static final AtomicInteger NEXT_ID_ATOMIC_INT = new AtomicInteger(0); + + + + public final long id; + + public final String resourceLocationNamespace; + public final String resourceLocationPath; + + /** If false the boxes will be positioned relative to the level's origin */ + public final boolean positionBoxesRelativeToGroupOrigin; + + private final List boxList; + /** backup list which allows for uploading the boxes even it the main list is being modified on a different thread. */ + private final List uploadBoxList; + private final DhApiVec3d originBlockPos; + + + public boolean active = true; + public boolean ssaoEnabled = true; + private boolean vertexDataDirty = true; + + public byte skyLight = LodUtil.MAX_MC_LIGHT; + public byte blockLight = LodUtil.MIN_MC_LIGHT; + public DhApiRenderableBoxGroupShading shading = DhApiRenderableBoxGroupShading.getDefaultShaded(); + + @Nullable + public Consumer beforeRenderFunc; + public Consumer afterRenderFunc; + + // instance data + public IGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + /** double buffering for thread safety and to prevent locking the render thread during update */ + private IGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + + + + //=================// + // getters/setters // + //=================// + //region + + @Override + public long getId() { return this.id; } + + @Override + public String getResourceLocationNamespace() { return this.resourceLocationNamespace; } + @Override + public String getResourceLocationPath() { return this.resourceLocationPath; } + + @Override + public void setOriginBlockPos(DhApiVec3d pos) + { + this.originBlockPos.x = pos.x; + this.originBlockPos.y = pos.y; + this.originBlockPos.z = pos.z; + } + + @Override + public DhApiVec3d getOriginBlockPos() { return new DhApiVec3d(this.originBlockPos.x, this.originBlockPos.y, this.originBlockPos.z); } + + + @Override + public void setSkyLight(int skyLight) + { + if (skyLight < LodUtil.MIN_MC_LIGHT + || skyLight > LodUtil.MAX_MC_LIGHT) + { + throw new IllegalArgumentException("Sky light ["+skyLight+"] must be between ["+LodUtil.MIN_MC_LIGHT+"] and ["+LodUtil.MAX_MC_LIGHT+"] (inclusive)."); + } + this.skyLight = (byte)skyLight; + } + @Override + public int getSkyLight() { return this.skyLight; } + + @Override + public void setBlockLight(int blockLight) + { + if (blockLight < LodUtil.MIN_MC_LIGHT + || blockLight > LodUtil.MAX_MC_LIGHT) + { + throw new IllegalArgumentException("Block light ["+blockLight+"] must be between ["+LodUtil.MIN_MC_LIGHT+"] and ["+LodUtil.MAX_MC_LIGHT+"] (inclusive)."); + } + this.blockLight = (byte)blockLight; + } + @Override + public int getBlockLight() { return this.blockLight; } + + @Override + public void setPreRenderFunc(Consumer func) { this.beforeRenderFunc = func; } + + @Override + public void setPostRenderFunc(Consumer func) { this.afterRenderFunc = func; } + + @Override + public void setActive(boolean active) { this.active = active; } + @Override + public boolean isActive() { return this.active; } + + @Override + public void setSsaoEnabled(boolean ssaoEnabled) { this.ssaoEnabled = ssaoEnabled; } + @Override + public boolean isSsaoEnabled() { return this.ssaoEnabled; } + + @Override + public void setShading(DhApiRenderableBoxGroupShading shading) { this.shading = shading; } + @Override + public DhApiRenderableBoxGroupShading getShading() { return this.shading; } + + //endregion + + + + //=============// + // constructor // + //=============// + //region + + public RenderableBoxGroup( + String resourceLocation, + DhApiVec3d originBlockPos, List boxList, + boolean positionBoxesRelativeToGroupOrigin) throws IllegalArgumentException + { + String[] splitResourceLocation = resourceLocation.split(":"); + if (splitResourceLocation.length != 2) + { + throw new IllegalArgumentException("Resource Location must be a string that's separated by a single colon, for example: [DistantHorizons:Beacons], your namespace ["+resourceLocation+"], contains ["+(splitResourceLocation.length-1)+"] colons."); + } + + this.resourceLocationNamespace = splitResourceLocation[0]; + this.resourceLocationPath = splitResourceLocation[1]; + + this.id = NEXT_ID_ATOMIC_INT.getAndIncrement(); + this.boxList = Collections.synchronizedList(new ArrayList<>(boxList)); + this.uploadBoxList = Collections.synchronizedList(new ArrayList<>(boxList)); + + this.originBlockPos = originBlockPos; + this.positionBoxesRelativeToGroupOrigin = positionBoxesRelativeToGroupOrigin; + } + + //endregion + + + + //=================// + // render building // + //=================// + //region + + @Override + public void triggerBoxChange() { this.vertexDataDirty = true; } + + /** + * Does nothing if the vertex data is already up-to-date + * and is meaningless if using direct rendering. + */ + public void tryUpdateInstancedDataAsync() + { + // if the alt container is done, swap it in + if (this.altVertexBufferContainer.getState() == NativeGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD) + { + this.altVertexBufferContainer.uploadDataToGpu(); + + // swap VBO references for rendering + IGenericObjectVertexBufferContainer temp = this.vertexBufferContainer; + this.vertexBufferContainer = this.altVertexBufferContainer; + this.altVertexBufferContainer = temp; + + this.vertexDataDirty = false; + + return; + } + + + + // if the vertex data is already up to date, do nothing + if (!this.vertexDataDirty) + { + return; + } + + PriorityTaskPicker.Executor executor = ThreadPoolUtil.getRenderLoadingExecutor(); + if (executor == null || executor.isTerminated()) + { + return; + } + + // if the alternate container is already updating, don't double-queue it + if (this.altVertexBufferContainer.getState() == NativeGlGenericObjectVertexContainer.EState.UPDATING_DATA) + { + return; + } + this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.UPDATING_DATA); + + + + //this.altInstancedVbos.tryRunRenderThreadSetup(); + + // copy over the box list so we can upload without concurrent modification issues + this.uploadBoxList.clear(); + synchronized (this.uploadBoxList) + { + this.uploadBoxList.addAll(this.boxList); + } + + try + { + executor.runTask(() -> + { + try + { + this.altVertexBufferContainer.updateVertexData(this.uploadBoxList); + } + catch (Exception e) + { + LOGGER.error("Unexpected error updating instanced VBO data for: ["+this+"], error: ["+e.getMessage()+"].", e); + this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.ERROR); + } + }); + } + catch (RejectedExecutionException ignore) + { + // the executor was shut down, it should be back up shortly and able to accept new jobs + this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.NEW); + } + } + + //endregion + + + + //===============// + // render events // + //===============// + //region + + /** + * This is called before every frame, even if {@link this#isActive()} returns false.
+ * {@link this#isActive()} can be changed at this point before the object is rendered to the frame. + */ + public void preRender(DhApiRenderParam renderEventParam) + { + if (this.beforeRenderFunc != null) + { + this.beforeRenderFunc.accept(renderEventParam); + } + } + /** + * Called after rendering is completed.
+ * Can be used to handle any necessary cleanup. + */ + public void postRender(DhApiRenderParam renderEventParam) + { + if (this.afterRenderFunc != null) + { + this.afterRenderFunc.accept(renderEventParam); + } + } + + //endregion + + + + //================// + // List Overrides // + //================// + //region + + @Override + public boolean add(DhApiRenderableBox box) { return this.boxList.add(box); } + @Override + public DhApiRenderableBox get(int index) { return this.boxList.get(index); } + @Override + public int size() { return this.boxList.size(); } + @Override + public boolean removeIf(Predicate filter) { return this.boxList.removeIf(filter); } + @Override + public boolean remove(Object obj) { return this.boxList.remove(obj); } + @Override + public DhApiRenderableBox remove(int index) { return this.boxList.remove(index); } + @Override + public void replaceAll(UnaryOperator operator) { this.boxList.replaceAll(operator); } + @Override + public void sort(Comparator comparator) { this.boxList.sort(comparator); } + @Override + public void forEach(Consumer action) { this.boxList.forEach(action); } + @Override + public Spliterator spliterator() { return this.boxList.spliterator(); } + @Override + public Stream stream() { return this.boxList.stream(); } + @Override + public Stream parallelStream() { return this.boxList.parallelStream(); } + @Override + public void clear() { this.boxList.clear(); } + + //endregion + + + + //================// + // base overrides // + //================// + //region + + @Override + public String toString() { return "["+this.resourceLocationNamespace+":"+this.resourceLocationPath+"] ID:["+this.id+"], pos:[("+this.originBlockPos.x+", "+this.originBlockPos.y+", "+this.originBlockPos.z+")], size:["+this.size()+"], active:["+this.active+"]"; } + + @Override + public void close() + { + RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> + { + this.vertexBufferContainer.close(); + this.altVertexBufferContainer.close(); + }); + } + + //endregion + + + +} + \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java new file mode 100644 index 000000000..f9fa9b921 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java @@ -0,0 +1,261 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject; + +import static org.lwjgl.opengl.GL46.*; + +// Turns GL int enums back to readable strings +public class GLEnums +{ + + public static String getString(int glEnum) + { + // blend stuff + switch (glEnum) + { + case GL_ZERO: + return "GL_ZERO"; + case GL_ONE: + return "GL_ONE"; + case GL_SRC_COLOR: + return "GL_SRC_COLOR"; + case GL_ONE_MINUS_SRC_COLOR: + return "GL_ONE_MINUS_SRC_COLOR"; + case GL_DST_COLOR: + return "GL_DST_COLOR"; + case GL_ONE_MINUS_DST_COLOR: + return "GL_ONE_MINUS_DST_COLOR"; + case GL_SRC_ALPHA: + return "GL_SRC_ALPHA"; + case GL_ONE_MINUS_SRC_ALPHA: + return "GL_ONE_MINUS_SRC_ALPHA"; + case GL_DST_ALPHA: + return "GL_DST_ALPHA"; + case GL_ONE_MINUS_DST_ALPHA: + return "GL_ONE_MINUS_DST_ALPHA"; + case GL_CONSTANT_COLOR: + return "GL_CONSTANT_COLOR"; + case GL_ONE_MINUS_CONSTANT_COLOR: + return "GL_ONE_MINUS_CONSTANT_COLOR"; + case GL_CONSTANT_ALPHA: + return "GL_CONSTANT_ALPHA"; + case GL_ONE_MINUS_CONSTANT_ALPHA: + return "GL_ONE_MINUS_CONSTANT_ALPHA"; + default: + } + + // shader stuff + switch (glEnum) + { + case GL_VERTEX_SHADER: + return "GL_VERTEX_SHADER"; + case GL_GEOMETRY_SHADER: + return "GL_GEOMETRY_SHADER"; + case GL_FRAGMENT_SHADER: + return "GL_FRAGMENT_SHADER"; + default: + } + + // stencil stuff + switch (glEnum) + { + case GL_KEEP: + return "GL_KEEP"; + case GL_ZERO: + return "GL_ZERO"; + case GL_REPLACE: + return "GL_REPLACE"; + case GL_INCR: + return "GL_INCR"; + case GL_DECR: + return "GL_DECR"; + case GL_INVERT: + return "GL_INVERT"; + case GL_INCR_WRAP: + return "GL_INCR_WRAP"; + case GL_DECR_WRAP: + return "GL_DECR_WRAP"; + default: + } + + // depth stuff + switch (glEnum) + { + case GL_NEVER: + return "GL_NEVER"; + case GL_LESS: + return "GL_LESS"; + case GL_EQUAL: + return "GL_EQUAL"; + case GL_LEQUAL: + return "GL_LEQUAL"; + case GL_GREATER: + return "GL_GREATER"; + case GL_NOTEQUAL: + return "GL_NOTEQUAL"; + case GL_GEQUAL: + return "GL_GEQUAL"; + case GL_ALWAYS: + return "GL_ALWAYS"; + default: + } + + // Texture binding points + switch (glEnum) + { + case GL_TEXTURE0: + return "GL_TEXTURE0"; + case GL_TEXTURE1: + return "GL_TEXTURE1"; + case GL_TEXTURE2: + return "GL_TEXTURE2"; + case GL_TEXTURE3: + return "GL_TEXTURE3"; + case GL_TEXTURE4: + return "GL_TEXTURE4"; + case GL_TEXTURE5: + return "GL_TEXTURE5"; + case GL_TEXTURE6: + return "GL_TEXTURE6"; + case GL_TEXTURE7: + return "GL_TEXTURE7"; + case GL_TEXTURE8: + return "GL_TEXTURE8"; + case GL_TEXTURE9: + return "GL_TEXTURE9"; + case GL_TEXTURE10: + return "GL_TEXTURE10"; + case GL_TEXTURE11: + return "GL_TEXTURE11"; + case GL_TEXTURE12: + return "GL_TEXTURE12"; + case GL_TEXTURE13: + return "GL_TEXTURE13"; + case GL_TEXTURE14: + return "GL_TEXTURE14"; + case GL_TEXTURE15: + return "GL_TEXTURE15"; + case GL_TEXTURE16: + return "GL_TEXTURE16"; + case GL_TEXTURE17: + return "GL_TEXTURE17"; + case GL_TEXTURE18: + return "GL_TEXTURE18"; + case GL_TEXTURE19: + return "GL_TEXTURE19"; + case GL_TEXTURE20: + return "GL_TEXTURE20"; + case GL_TEXTURE21: + return "GL_TEXTURE21"; + case GL_TEXTURE22: + return "GL_TEXTURE22"; + case GL_TEXTURE23: + return "GL_TEXTURE23"; + case GL_TEXTURE24: + return "GL_TEXTURE24"; + case GL_TEXTURE25: + return "GL_TEXTURE25"; + case GL_TEXTURE26: + return "GL_TEXTURE26"; + case GL_TEXTURE27: + return "GL_TEXTURE27"; + case GL_TEXTURE28: + return "GL_TEXTURE28"; + case GL_TEXTURE29: + return "GL_TEXTURE29"; + case GL_TEXTURE30: + return "GL_TEXTURE30"; + case GL_TEXTURE31: + return "GL_TEXTURE31"; + default: + } + + // Polygon modes + switch (glEnum) + { + case GL_POINT: + return "GL_POINT"; + case GL_LINE: + return "GL_LINE"; + case GL_FILL: + return "GL_FILL"; + default: + } + + // Culling modes + switch (glEnum) + { + case GL_FRONT: + return "GL_FRONT"; + case GL_BACK: + return "GL_BACK"; + case GL_FRONT_AND_BACK: + return "GL_FRONT_AND_BACK"; + default: + } + + // Types + switch (glEnum) + { + case GL_BYTE: + return "GL_BYTE"; + case GL_UNSIGNED_BYTE: + return "GL_UNSIGNED_BYTE"; + case GL_SHORT: + return "GL_SHORT"; + case GL_UNSIGNED_SHORT: + return "GL_UNSIGNED_SHORT"; + case GL_INT: + return "GL_INT"; + case GL_UNSIGNED_INT: + return "GL_UNSIGNED_INT"; + case GL_FLOAT: + return "GL_FLOAT"; + case GL_DOUBLE: + return "GL_DOUBLE"; + default: + } + + return "GL_UNKNOWN(" + glEnum + ")"; + } + + public static int getTypeSize(int glTypeEnum) + { + switch (glTypeEnum) + { + case GL_BYTE: + case GL_UNSIGNED_BYTE: + return 1; + case GL_SHORT: + case GL_UNSIGNED_SHORT: + return 2; + case GL_INT: + case GL_UNSIGNED_INT: + return 4; + case GL_FLOAT: + return 4; + case GL_DOUBLE: + return 8; + default: + throw new IllegalArgumentException("Unknown type enum: " + getString(glTypeEnum)); + } + } + +} \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java new file mode 100644 index 000000000..1e0280cc8 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java @@ -0,0 +1,351 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGLErrorHandlingMode; +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.jar.EPlatform; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.TimerUtil; +import com.seibel.distanthorizons.core.util.objects.GLMessages.*; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.coreapi.ModInfo; +import org.lwjgl.glfw.GLFW; +import org.lwjgl.opengl.GL; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GLCapabilities; +import org.lwjgl.opengl.GLUtil; + +import java.io.PrintStream; +import java.util.Collections; +import java.util.Set; +import java.util.Timer; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; + +/** + * A singleton that holds references to different openGL contexts + * and GPU capabilities. + */ +public class GLProxy +{ + public static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) + .chatLevelConfig(Config.Common.Logging.logRendererGLEventToChat) + .build(); + + public static final Set LOGGED_GL_MESSAGES = Collections.newSetFromMap(new ConcurrentHashMap()); + + + + private static GLProxy instance = null; + + + /** Minecraft's GL capabilities */ + public final GLCapabilities glCapabilities; + + public boolean namedObjectSupported = false; // ~OpenGL 4.5 (UNUSED CURRENTLY) + public boolean bufferStorageSupported = false; // ~OpenGL 4.4 + public boolean vertexAttributeBufferBindingSupported = false; // ~OpenGL 4.3 + public boolean instancedArraysSupported = false; + public boolean vertexAttribDivisorSupported = false; // OpenGL 3.3 or newer + + private final EDhApiGpuUploadMethod preferredUploadMethod; + + public final GLMessageBuilder vanillaDebugMessageBuilder = + new GLMessageBuilder( + (type) -> + { + if (type == EGLMessageType.POP_GROUP) + return false; + else if (type == EGLMessageType.PUSH_GROUP) + return false; + else if (type == EGLMessageType.MARKER) + return false; + else + return true; + }, + (severity) -> + { + // notifications can generally be ignored (if they are logged at all) + if (severity == EGLMessageSeverity.NOTIFICATION) + return false; + else + return true; + }, + null + ); + + + + //=============// + // constructor // + //=============// + //region + + private GLProxy() throws IllegalStateException + { + // this must be created on minecraft's render context to work correctly + if (GLFW.glfwGetCurrentContext() == 0L) + { + throw new IllegalStateException(GLProxy.class.getSimpleName() + " was created outside the render thread!"); + } + + LOGGER.info("Creating " + GLProxy.class.getSimpleName() + "... If this is the last message you see there must have been an OpenGL error."); + LOGGER.info("Lod Render OpenGL version [" + GL32.glGetString(GL32.GL_VERSION) + "]."); + + + + + //============================// + // get Minecraft's GL context // + //============================// + + // get Minecraft's capabilities + this.glCapabilities = GL.getCapabilities(); + + // crash the game if the GPU doesn't support OpenGL 3.2 + if (!this.glCapabilities.OpenGL32) + { + String supportedVersionInfo = this.getFailedVersionInfo(this.glCapabilities); + + // See full requirement at above. + String errorMessage = ModInfo.READABLE_NAME + " was initializing " + GLProxy.class.getSimpleName() + + " and discovered this GPU doesn't meet the OpenGL requirements. Sorry I couldn't tell you sooner :(\n" + + "Additional info:\n" + supportedVersionInfo; + IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + MC.crashMinecraft(errorMessage, new UnsupportedOperationException("Distant Horizon OpenGL requirements not met")); + } + LOGGER.info("minecraftGlCapabilities:\n" + this.versionInfoToString(this.glCapabilities)); + + if (Config.Client.Advanced.Debugging.OpenGl.overrideVanillaGLLogger.get()) + { + GLUtil.setupDebugMessageCallback(new PrintStream(new GLMessageOutputStream(GLProxy::logMessage, this.vanillaDebugMessageBuilder), true)); + } + + + + //======================// + // get GPU capabilities // + //======================// + + // UNUSED currently + // Check if we can use the named version of all calls, which is available in GL4.5 or after + this.namedObjectSupported = this.glCapabilities.glNamedBufferData != 0L; //Nullptr + + // Check if we can use the Buffer Storage, which is available in GL4.4 or after + this.bufferStorageSupported = this.glCapabilities.glBufferStorage != 0L; // Nullptr + if (!this.bufferStorageSupported) + { + LOGGER.info("This GPU doesn't support Buffer Storage (OpenGL 4.4), falling back to using other methods."); + } + + // Check if we can use the make-over version of Vertex Attribute, which is available in GL4.3 or after + this.vertexAttributeBufferBindingSupported = this.glCapabilities.glBindVertexBuffer != 0L; // Nullptr + + // used by instanced rendering + this.vertexAttribDivisorSupported = this.glCapabilities.OpenGL33; + // denotes if ARBInstancedArrays.glVertexAttribDivisorARB() is available or not + // can be used as a backup if MC didn't create a GL 3.3+ context + this.instancedArraysSupported = this.glCapabilities.GL_ARB_instanced_arrays; + + // get the best automatic upload method + String vendor = GL32.glGetString(GL32.GL_VENDOR).toUpperCase(); // example return: "NVIDIA CORPORATION" + if (EPlatform.get() != EPlatform.MACOS) + { + if (vendor.contains("NVIDIA") || vendor.contains("GEFORCE")) + { + // NVIDIA card + this.preferredUploadMethod = this.bufferStorageSupported ? EDhApiGpuUploadMethod.BUFFER_STORAGE : EDhApiGpuUploadMethod.SUB_DATA; + } + else + { + // AMD or Intel card + this.preferredUploadMethod = this.bufferStorageSupported ? EDhApiGpuUploadMethod.BUFFER_STORAGE : EDhApiGpuUploadMethod.DATA; + } + } + else + { + // Mac may have an issue with Buffer Storage, so default to the most basic + // form of uploading + this.preferredUploadMethod = EDhApiGpuUploadMethod.DATA; + } + LOGGER.info("GPU Vendor [" + vendor + "] with OS [" + EPlatform.get().getName() + "], Preferred upload method is [" + this.preferredUploadMethod + "]."); + + + + //==========// + // clean up // + //==========// + + // GLProxy creation success + LOGGER.info(GLProxy.class.getSimpleName() + " creation successful. OpenGL smiles upon you this day."); + } + + //endregion + + + + //=========// + // getters // + //=========// + //region + + public static boolean hasInstance() { return instance != null; } + /** @throws IllegalStateException if the Proxy hasn't been created yet and this is called outside the render thread */ + public static GLProxy getInstance() throws IllegalStateException + { + if (instance == null) + { + instance = new GLProxy(); + } + + return instance; + } + + public EDhApiGpuUploadMethod getGpuUploadMethod() + { + EDhApiGpuUploadMethod uploadOverride = Config.Client.Advanced.Debugging.OpenGl.glUploadMode.get(); + if (uploadOverride == EDhApiGpuUploadMethod.AUTO) + { + return this.preferredUploadMethod; + } + + return uploadOverride; + } + + public static boolean runningOnRenderThread() + { + long currentContext = GLFW.glfwGetCurrentContext(); + return currentContext != 0L; // if the context isn't null, it's the MC context + } + + //endregion + + + + //=========// + // logging // + //=========// + //region + + /** this method is called on the render thread at the point of the GL Error */ + private static void logMessage(GLMessage msg) + { + EDhApiGLErrorHandlingMode errorHandlingMode = Config.Client.Advanced.Debugging.OpenGl.glErrorHandlingMode.get(); + if (errorHandlingMode == EDhApiGLErrorHandlingMode.IGNORE) + { + return; + } + + + + boolean onlyLogOnce = Config.Client.Advanced.Debugging.OpenGl.onlyLogGlErrorsOnce.get(); + String errorMessage = "GL ERROR [" + msg.id + "] from [" + msg.source + "]: [" + msg.message + "]"+(onlyLogOnce ? " this message will only be logged once" : "")+"."; + if (onlyLogOnce + && !LOGGED_GL_MESSAGES.add(errorMessage)) + { + // this message has already been logged + return; + } + + + // create an exception so we get a stacktrace of where the message was triggered from + RuntimeException exception = new RuntimeException(errorMessage); + + if (msg.type == EGLMessageType.ERROR || msg.type == EGLMessageType.UNDEFINED_BEHAVIOR) + { + // critical error + + LOGGER.error(exception.getMessage(), exception); + + if (errorHandlingMode == EDhApiGLErrorHandlingMode.LOG_THROW) + { + // will probably crash the game, + // good for quickly checking if there's a problem while preventing log spam + throw exception; + } + } + else + { + // non-critical log + + EGLMessageSeverity severity = msg.severity; + if (severity == null) + { + // just in case the message was malformed + severity = EGLMessageSeverity.LOW; + } + + switch (severity) + { + case HIGH: + LOGGER.error(exception.getMessage(), exception); + break; + case MEDIUM: + LOGGER.warn(exception.getMessage(), exception); + break; + case LOW: + LOGGER.info(exception.getMessage(), exception); + break; + case NOTIFICATION: + LOGGER.debug(exception.getMessage(), exception); + break; + } + } + } + + //endregion + + + + //================// + // helper methods // + //================// + //region + + private String getFailedVersionInfo(GLCapabilities c) + { + return "Your OpenGL support:\n" + + "openGL version 3.2+: [" + c.OpenGL32 + "] <- REQUIRED\n" + + "Vertex Attribute Buffer Binding: [" + (c.glVertexAttribBinding != 0) + "] <- optional improvement\n" + + "Buffer Storage: [" + (c.glBufferStorage != 0) + "] <- optional improvement\n" + + "If you noticed that your computer supports higher OpenGL versions" + + " but not the required version, try running the game in compatibility mode." + + " (How you turn that on, I have no clue~)"; + } + + private String versionInfoToString(GLCapabilities c) + { + return "Your OpenGL support:\n" + + "openGL version 3.2+: [" + c.OpenGL32 + "] <- REQUIRED\n" + + "Vertex Attribute Buffer Binding: [" + (c.glVertexAttribBinding != 0) + "] <- optional improvement\n" + + "Buffer Storage: [" + (c.glBufferStorage != 0) + "] <- optional improvement\n"; + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java new file mode 100644 index 000000000..d3511539b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java @@ -0,0 +1,259 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject; + +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import org.lwjgl.opengl.GL32; + +public class GLState implements AutoCloseable +{ + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int program; + public int vao; + public int vbo; + public int ebo; + public int fbo; + public int texture2D; + /** IE: GL_TEXTURE0, GL_TEXTURE1, etc. */ + public int activeTextureNumber; + public int texture0; + public int texture1; + public int texture2; + public int texture3; + public int frameBufferTexture0; + public int frameBufferTexture1; + public int frameBufferDepthTexture; + public boolean blend; + public boolean scissor; + public int blendEqRGB; + public int blendEqAlpha; + public int blendSrcColor; + public int blendSrcAlpha; + public int blendDstColor; + public int blendDstAlpha; + public boolean depth; + public boolean writeToDepthBuffer; + public int depthFunc; + public boolean stencil; + public int stencilFunc; + public int stencilRef; + public int stencilMask; + public int[] view; + public boolean cull; + public int cullMode; + public int polyMode; + + + + public GLState() { this.saveState(); } + + public void saveState() + { + this.program = GL32.glGetInteger(GL32.GL_CURRENT_PROGRAM); + this.vao = GL32.glGetInteger(GL32.GL_VERTEX_ARRAY_BINDING); + this.vbo = GL32.glGetInteger(GL32.GL_ARRAY_BUFFER_BINDING); + this.ebo = GL32.glGetInteger(GL32.GL_ELEMENT_ARRAY_BUFFER_BINDING); + + this.fbo = GL32.glGetInteger(GL32.GL_FRAMEBUFFER_BINDING); + + this.texture2D = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); + this.activeTextureNumber = GL32.glGetInteger(GL32.GL_ACTIVE_TEXTURE); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + this.texture0 = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + this.texture1 = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); + + GLMC.glActiveTexture(GL32.GL_TEXTURE2); // problem with Iris + this.texture2 = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); + + GLMC.glActiveTexture(GL32.GL_TEXTURE3); + this.texture3 = GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); + + GLMC.glActiveTexture(this.activeTextureNumber); + + if (this.fbo != 0) + { + this.frameBufferTexture0 = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + this.frameBufferTexture1 = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT1, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + this.frameBufferDepthTexture = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_DEPTH_ATTACHMENT, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + } + else + { + // attempting to get values from the default framebuffer can throw errors on Linux + this.frameBufferTexture0 = 0; + this.frameBufferTexture1 = 0; + this.frameBufferDepthTexture = 0; + } + + this.blend = GL32.glIsEnabled(GL32.GL_BLEND); + this.scissor = GL32.glIsEnabled(GL32.GL_SCISSOR_TEST); + this.blendEqRGB = GL32.glGetInteger(GL32.GL_BLEND_EQUATION_RGB); + this.blendEqAlpha = GL32.glGetInteger(GL32.GL_BLEND_EQUATION_ALPHA); + this.blendSrcColor = GL32.glGetInteger(GL32.GL_BLEND_SRC_RGB); + this.blendSrcAlpha = GL32.glGetInteger(GL32.GL_BLEND_SRC_ALPHA); + this.blendDstColor = GL32.glGetInteger(GL32.GL_BLEND_DST_RGB); + this.blendDstAlpha = GL32.glGetInteger(GL32.GL_BLEND_DST_ALPHA); + this.depth = GL32.glIsEnabled(GL32.GL_DEPTH_TEST); + this.writeToDepthBuffer = GL32.glGetInteger(GL32.GL_DEPTH_WRITEMASK) == GL32.GL_TRUE; + this.depthFunc = GL32.glGetInteger(GL32.GL_DEPTH_FUNC); + this.stencil = GL32.glIsEnabled(GL32.GL_STENCIL_TEST); + this.stencilFunc = GL32.glGetInteger(GL32.GL_STENCIL_FUNC); + this.stencilRef = GL32.glGetInteger(GL32.GL_STENCIL_REF); + this.stencilMask = GL32.glGetInteger(GL32.GL_STENCIL_VALUE_MASK); + this.view = new int[4]; + GL32.glGetIntegerv(GL32.GL_VIEWPORT, this.view); + this.cull = GL32.glIsEnabled(GL32.GL_CULL_FACE); + this.cullMode = GL32.glGetInteger(GL32.GL_CULL_FACE_MODE); + this.polyMode = GL32.glGetInteger(GL32.GL_POLYGON_MODE); + } + + @Override + public void close() + { + // explicitly unbinding the frame buffer is necessary to prevent GL_CLEAR calls from hitting the wrong buffer + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, 0); + boolean frameBufferSet = false; + + if (this.fbo != 0 && GL32.glIsFramebuffer(this.fbo)) + { + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.fbo); + frameBufferSet = true; + } + + + if (this.blend) + { + GLMC.enableBlend(); + } + else + { + GLMC.disableBlend(); + } + + if (this.scissor) + { + GLMC.enableScissorTest(); + } + else + { + GLMC.disableScissorTest(); + } + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(GL32.glIsTexture(this.texture0) ? this.texture0 : 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(GL32.glIsTexture(this.texture1) ? this.texture1 : 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE2); + GLMC.glBindTexture(GL32.glIsTexture(this.texture2) ? this.texture2 : 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE3); + GLMC.glBindTexture(GL32.glIsTexture(this.texture3) ? this.texture3 : 0); + + GLMC.glActiveTexture(this.activeTextureNumber); + GLMC.glBindTexture(GL32.glIsTexture(this.texture2D) ? this.texture2D : 0); + + // attempting to set textures on the default frame buffer (ID 0) will throw errors + if (frameBufferSet) + { + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, this.frameBufferTexture0, 0); + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT1, GL32.GL_TEXTURE_2D, this.frameBufferTexture1, 0); + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_DEPTH_ATTACHMENT, GL32.GL_TEXTURE_2D, this.frameBufferDepthTexture, 0); + } + + GL32.glBindVertexArray(GL32.glIsVertexArray(this.vao) ? this.vao : 0); + GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, GL32.glIsBuffer(this.vbo) ? this.vbo : 0); + GL32.glBindBuffer(GL32.GL_ELEMENT_ARRAY_BUFFER, GL32.glIsBuffer(this.ebo) ? this.ebo: 0); + GL32.glUseProgram(GL32.glIsProgram(this.program) ? this.program : 0); + + if (this.writeToDepthBuffer) + { + GLMC.enableDepthMask(); + } + else + { + GLMC.disableDepthMask(); + } + + GLMC.glBlendFunc(this.blendSrcColor, this.blendDstColor); + GL32.glBlendEquationSeparate(this.blendEqRGB, this.blendEqAlpha); + GLMC.glBlendFuncSeparate(this.blendSrcColor, this.blendDstColor, this.blendSrcAlpha, this.blendDstAlpha); + + if (this.depth) + { + GLMC.enableDepthTest(); + } + else + { + GLMC.disableDepthTest(); + } + GLMC.glDepthFunc(this.depthFunc); + + if (this.stencil) + { + GL32.glEnable(GL32.GL_STENCIL_TEST); + } + else + { + GL32.glDisable(GL32.GL_STENCIL_TEST); + } + GL32.glStencilFunc(this.stencilFunc, this.stencilRef, this.stencilMask); + + GL32.glViewport(this.view[0], this.view[1], this.view[2], this.view[3]); + if (this.cull) + { + GLMC.enableFaceCulling(); + } + else + { + GLMC.disableFaceCulling(); + } + GL32.glCullFace(this.cullMode); + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, this.polyMode); + } + + @Override + public String toString() + { + return "GLState{" + + "program=" + this.program + ", vao=" + this.vao + ", vbo=" + this.vbo + ", ebo=" + this.ebo + ", fbo=" + this.fbo + + ", text=" + GLEnums.getString(this.texture2D) + "@" + this.activeTextureNumber + ", text0=" + GLEnums.getString(this.texture0) + + ", FB text0=" + this.frameBufferTexture0 + + ", FB text1=" + this.frameBufferTexture1 + + ", FB depth=" + this.frameBufferDepthTexture + + ", blend=" + this.blend + ", scissor=" + this.scissor + ", blendMode=" + GLEnums.getString(this.blendSrcColor) + "," + GLEnums.getString(this.blendDstColor) + + ", depth=" + this.depth + + ", depthFunc=" + GLEnums.getString(this.depthFunc) + ", stencil=" + this.stencil + + ", stencilFunc=" + GLEnums.getString(this.stencilFunc) + ", stencilRef=" + this.stencilRef + ", stencilMask=" + this.stencilMask + + ", view={x:" + this.view[0] + ", y:" + this.view[1] + + ", w:" + this.view[2] + ", h:" + this.view[3] + "}" + ", cull=" + this.cull + + ", cullMode=" + GLEnums.getString(this.cullMode) + ", polyMode=" + GLEnums.getString(this.polyMode) + + '}'; + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java new file mode 100644 index 000000000..258b35bf6 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java @@ -0,0 +1,345 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.util.ThreadUtil; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL44; + +import java.lang.ref.PhantomReference; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.nio.ByteBuffer; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.atomic.AtomicInteger; + +public class GLBuffer implements AutoCloseable +{ + private static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) + .chatLevelConfig(Config.Common.Logging.logRendererGLEventToChat) + .build(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public static final double BUFFER_EXPANSION_MULTIPLIER = 1.3; + public static final double BUFFER_SHRINK_TRIGGER = BUFFER_EXPANSION_MULTIPLIER * BUFFER_EXPANSION_MULTIPLIER; + /** the number of active buffers, can be used for debugging */ + public static AtomicInteger bufferCount = new AtomicInteger(0); + + private static final int PHANTOM_REF_CHECK_TIME_IN_MS = 5 * 1000; + private static final ConcurrentHashMap, Integer> PHANTOM_TO_BUFFER_ID = new ConcurrentHashMap<>(); + private static final ConcurrentHashMap> BUFFER_ID_TO_PHANTOM = new ConcurrentHashMap<>(); + private static final ReferenceQueue PHANTOM_REFERENCE_QUEUE = new ReferenceQueue<>(); + private static final ThreadPoolExecutor CLEANUP_THREAD = ThreadUtil.makeSingleDaemonThreadPool("GLBuffer Cleanup"); + + + protected int id; + public final int getId() { return this.id; } + protected int size = 0; + public int getSize() { return this.size; } + protected boolean bufferStorage; + public final boolean isBufferStorage() { return this.bufferStorage; } + protected boolean isMapped = false; + + + + //==============// + // constructors // + //==============// + + static { CLEANUP_THREAD.execute(() -> runPhantomReferenceCleanupLoop()); } + + public GLBuffer(boolean isBufferStorage) { this.create(isBufferStorage); } + + + + //=========// + // methods // + //=========// + + // Should be override by subclasses + public int getBufferBindingTarget() { return GL32.GL_COPY_READ_BUFFER; } + + public void bind() { GL32.glBindBuffer(this.getBufferBindingTarget(), this.id); } + public void unbind() { GL32.glBindBuffer(this.getBufferBindingTarget(), 0); } + + + + //====================// + // create and destroy // + //====================// + + protected void create(boolean asBufferStorage) + { + if (!GLProxy.runningOnRenderThread()) + { + LodUtil.assertNotReach("Thread ["+Thread.currentThread()+"] tried to create a GLBuffer outside the MC render thread."); + } + + // destroy the old buffer if one is present + // (as of 2024-12-31 James didn't see this happen, but just in case) + if (this.id != 0) + { + destroyBufferIdAsync(this.id); + } + + this.id = GLMC.glGenBuffers(); + this.bufferStorage = asBufferStorage; + bufferCount.getAndIncrement(); + + PhantomReference phantom = new PhantomReference<>(this, PHANTOM_REFERENCE_QUEUE); + PHANTOM_TO_BUFFER_ID.put(phantom, this.id); + BUFFER_ID_TO_PHANTOM.put(this.id, phantom); + + } + + protected void destroyAsync() + { + if (this.id == 0) + { + // the buffer has already been closed + return; + } + + destroyBufferIdAsync(this.id); + + this.id = 0; + this.size = 0; + } + private static void destroyBufferIdAsync(int id) + { + // remove and clear the phantom reference if present + if (BUFFER_ID_TO_PHANTOM.containsKey(id)) + { + Reference phantom = BUFFER_ID_TO_PHANTOM.get(id); + + // if we are manually closing this buffer, we don't want the phantom reference to accidentally close it again + // this can cause a race condition were we accidentally delete an in-use buffer and cause NVIDIA + // to throw an EXCEPTION_ACCESS_VIOLATION when we attempt to render it + phantom.clear(); + + PHANTOM_TO_BUFFER_ID.remove(phantom); + BUFFER_ID_TO_PHANTOM.remove(id); + } + + RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> + { + // destroy the buffer if it exists, + // the buffer may not exist if the destroy method is called twice + if (GL32.glIsBuffer(id)) + { + GLMC.glDeleteBuffers(id); + bufferCount.decrementAndGet(); + + if (Config.Client.Advanced.Debugging.logBufferGarbageCollection.get()) + { + LOGGER.info("destroyed buffer [" + id + "], remaining: [" + BUFFER_ID_TO_PHANTOM.size() + "]"); + } + } + }); + } + + + + //==================// + // buffer uploading // + //==================// + + /** + * Assumes the GL Context is already bound.
+ * Will create the VBO if one exist. + */ + public void uploadBuffer(ByteBuffer bb, EDhApiGpuUploadMethod uploadMethod, int maxExpansionSize, int bufferHint) + { + LodUtil.assertTrue(!uploadMethod.useEarlyMapping, "UploadMethod signal that this should use Mapping instead of uploadBuffer!"); + int bbSize = bb.limit() - bb.position(); + if (bbSize > maxExpansionSize) + { + LodUtil.assertNotReach("maxExpansionSize is [" + maxExpansionSize + "] but buffer size is [" + bbSize + "]!"); + } + + // Don't upload an empty buffer + if (bbSize == 0) + { + return; + } + + // make sure the buffer is ready for uploading + this.createOrChangeBufferTypeForUpload(uploadMethod); + + switch (uploadMethod) + { + //case NONE: + // return; + case AUTO: + LodUtil.assertNotReach("GpuUploadMethod AUTO must be resolved before call to uploadBuffer()!"); + case BUFFER_STORAGE: + this.uploadBufferStorage(bb, bufferHint); + break; + case DATA: + this.uploadBufferData(bb, bufferHint); + break; + case SUB_DATA: + this.uploadSubData(bb, maxExpansionSize, bufferHint); + break; + default: + LodUtil.assertNotReach("Unknown GpuUploadMethod!"); + } + } + /** Requires the buffer to be bound */ + protected void uploadBufferStorage(ByteBuffer bb, int bufferStorageHint) + { + LodUtil.assertTrue(this.bufferStorage, "Buffer is not bufferStorage but its trying to use bufferStorage upload method!"); + + int bbSize = bb.limit() - bb.position(); + this.destroyAsync(); + this.create(true); + this.bind(); + GL44.glBufferStorage(this.getBufferBindingTarget(), bb, 0); + this.size = bbSize; + } + /** Requires the buffer to be bound */ + protected void uploadBufferData(ByteBuffer bb, int bufferDataHint) + { + LodUtil.assertTrue(!this.bufferStorage, "Buffer is bufferStorage but its trying to use bufferData upload method!"); + + int bbSize = bb.limit() - bb.position(); + GL32.glBufferData(this.getBufferBindingTarget(), bb, bufferDataHint); + this.size = bbSize; + } + /** Requires the buffer to be bound */ + protected void uploadSubData(ByteBuffer bb, int maxExpansionSize, int bufferDataHint) + { + LodUtil.assertTrue(!this.bufferStorage, "Buffer is bufferStorage but its trying to use subData upload method!"); + + int bbSize = bb.limit() - bb.position(); + if (this.size < bbSize || this.size > bbSize * BUFFER_SHRINK_TRIGGER) + { + int newSize = (int) (bbSize * BUFFER_EXPANSION_MULTIPLIER); + if (newSize > maxExpansionSize) newSize = maxExpansionSize; + GL32.glBufferData(this.getBufferBindingTarget(), newSize, bufferDataHint); + this.size = newSize; + } + GL32.glBufferSubData(this.getBufferBindingTarget(), 0, bb); + } + + + + //===========// + // overrides // + //===========// + + @Override + public void close() { this.destroyAsync(); } + + @Override + public String toString() + { + return (this.bufferStorage ? "" : "Static-") + this.getClass().getSimpleName() + + "[id:" + this.id + ",size:" + this.size + (this.isMapped ? ",MAPPED" : "") + "]"; + } + + + + //================// + // helper methods // + //================// + + /** + * Makes sure the buffer exists and is of the correct format + * before uploading. + */ + private void createOrChangeBufferTypeForUpload(EDhApiGpuUploadMethod uploadMethod) + { + // create/change the buffer type if necessary + if (uploadMethod.useBufferStorage != this.bufferStorage) + { + // recreate if the buffer storage type changed + this.bind(); + this.destroyAsync(); + this.create(uploadMethod.useBufferStorage); + this.bind(); + } + else + { + // Prevent uploading to the null buffer (ID 0). + // This can happen if the buffer was deleted previously. + if (this.id == 0) + { + this.create(this.bufferStorage); + } + + this.bind(); + } + } + + + + //================// + // static cleanup // + //================// + + private static void runPhantomReferenceCleanupLoop() + { + while (true) + { + try + { + try + { + Thread.sleep(PHANTOM_REF_CHECK_TIME_IN_MS); + } + catch (InterruptedException ignore) { } + + + Reference phantomRef = PHANTOM_REFERENCE_QUEUE.poll(); + while (phantomRef != null) + { + // destroy the buffer if it hasn't been cleared yet + if (PHANTOM_TO_BUFFER_ID.containsKey(phantomRef)) + { + int id = PHANTOM_TO_BUFFER_ID.get(phantomRef); + destroyBufferIdAsync(id); + //LOGGER.warn("Buffer Phantom collected, ID: ["+id+"]"); + } + + phantomRef = PHANTOM_REFERENCE_QUEUE.poll(); + } + } + catch (Exception e) + { + LOGGER.error("Unexpected error in buffer cleanup thread: [" + e.getMessage() + "].", e); + } + } + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java new file mode 100644 index 000000000..d69818bf6 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java @@ -0,0 +1,60 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; + +import org.lwjgl.opengl.GL32; + +/** + * This is a container for a OpenGL + * VBO (Vertex Buffer Object). + * + * @author James Seibel + * @version 11-20-2021 + */ +public class GLElementBuffer extends GLBuffer +{ + /** + * When uploading to a buffer that is too small, recreate it this many times + * bigger than the upload payload + */ + protected int indicesCount = 0; + public int getIndicesCount() { return this.indicesCount; } + protected int type = GL32.GL_UNSIGNED_INT; + public int getType() { return type; } + + public GLElementBuffer(boolean isBufferStorage) + { + super(isBufferStorage); + } + + @Override + public void destroyAsync() + { + super.destroyAsync(); + this.indicesCount = 0; + } + + @Override + public int getBufferBindingTarget() + { + return GL32.GL_ELEMENT_ARRAY_BUFFER; + } + +} \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java new file mode 100644 index 000000000..ad9582239 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java @@ -0,0 +1,88 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; + +import java.nio.ByteBuffer; + +import org.lwjgl.opengl.GL32; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; + +/** + * This is a container for a OpenGL + * VBO (Vertex Buffer Object). + * + * @author James Seibel + * @version 11-20-2021 + */ +public class GLVertexBuffer extends GLBuffer +{ + /** + * When uploading to a buffer that is too small, recreate it this many times + * bigger than the upload payload + */ + protected int vertexCount = 0; + public int getVertexCount() { return this.vertexCount; } + // FIXME: This setter is needed for premapping buffer to manually set the vertexCount. Fix this. + public void setVertexCount(int vertexCount) { this.vertexCount = vertexCount; } + + + public GLVertexBuffer(boolean isBufferStorage) + { + super(isBufferStorage); + } + + + + @Override + public void destroyAsync() + { + super.destroyAsync(); + this.vertexCount = 0; + } + + @Override + public int getBufferBindingTarget() { return GL32.GL_ARRAY_BUFFER; } + + /** + * bufferSize is the number of shared verticies.
+ * This number will be higher when actually rendered since each box's face needs 2 triangles + * with 2 shared verticies. + */ + public void uploadBuffer(ByteBuffer byteBuffer, int bufferSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize) + { + if (bufferSize < 0) + { + throw new IllegalArgumentException("VertCount is negative!"); + } + + // If size is zero, just ignore it. + if (byteBuffer.limit() - byteBuffer.position() != 0) + { + boolean useBuffStorage = uploadMethod.useBufferStorage; + super.uploadBuffer(byteBuffer, uploadMethod, maxExpensionSize, useBuffStorage ? 0 : GL32.GL_STATIC_DRAW); + } + + // /4 to get the number of cubes + // *6 to get the number of verticies (2 triangles, 3 verticies each) + this.vertexCount = (bufferSize / 4) * 6; + } + +} \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java new file mode 100644 index 000000000..953d4dae4 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java @@ -0,0 +1,192 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import org.lwjgl.opengl.GL32; +import org.lwjgl.system.MemoryUtil; + +import java.nio.ByteBuffer; + +/** AKA Index Buffer TODO RENAME */ +public class QuadElementBuffer extends GLElementBuffer +{ + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + + + //=============// + // constructor // + //=============// + //region + + public QuadElementBuffer() { super(false); } + + public void reserve(int quadCount) + { + if (quadCount < 0) + { + throw new IllegalArgumentException("quadCount must be greater than 0"); + } + if (quadCount == 0) + { + // shouldn't happen, but just in case + return; + } + + this.indicesCount = quadCount * 6; // 2 triangles per quad + if (this.indicesCount >= this.getCapacity() + && this.indicesCount < this.getCapacity() * BUFFER_SHRINK_TRIGGER) + { + return; + } + int vertexCount = quadCount * 4; // 4 vertices per quad + + if (vertexCount < 255) + { + // Reserve 1 for the reset index + this.type = GL32.GL_UNSIGNED_BYTE; + } + else if (vertexCount < 65535) + { + // Reserve 1 for the reset index + this.type = GL32.GL_UNSIGNED_SHORT; + } + else + { + this.type = GL32.GL_UNSIGNED_INT; + } + + ByteBuffer buffer = MemoryUtil.memAlloc(this.indicesCount * GLEnums.getTypeSize(this.type)); + buildBuffer(quadCount, buffer, this.type); + this.bind(); + super.uploadBuffer(buffer, EDhApiGpuUploadMethod.DATA, + this.indicesCount * GLEnums.getTypeSize(this.type), GL32.GL_STATIC_DRAW); + + MemoryUtil.memFree(buffer); + } + + //endregion + + + + //=========// + // getters // + //=========// + //region + + public int getCapacity() { return super.getSize() / GLEnums.getTypeSize(this.getType()); } + + //endregion + + + + //==========// + // building // + //==========// + //region + + public static void buildBuffer(int quadCount, ByteBuffer buffer, int type) + { + switch (type) + { + case GL32.GL_UNSIGNED_BYTE: + buildBufferByte(quadCount, buffer); + break; + case GL32.GL_UNSIGNED_SHORT: + buildBufferShort(quadCount, buffer); + break; + case GL32.GL_UNSIGNED_INT: + buildBufferInt(quadCount, buffer); + break; + default: + throw new IllegalStateException("Unknown buffer type: [" + type + "]."); + } + } + + private static void buildBufferByte(int quadCount, ByteBuffer buffer) + { + for (int i = 0; i < quadCount; i++) + { + int vIndex = i * 4; + // First triangle + buffer.put((byte) (vIndex)); + buffer.put((byte) (vIndex + 1)); + buffer.put((byte) (vIndex + 2)); + // Second triangle + buffer.put((byte) (vIndex + 2)); + buffer.put((byte) (vIndex + 3)); + buffer.put((byte) (vIndex)); + } + if (buffer.hasRemaining()) + { + throw new IllegalStateException("QuadElementBuffer is not full somehow after building"); + } + buffer.rewind(); + } + private static void buildBufferShort(int quadCount, ByteBuffer buffer) + { + for (int i = 0; i < quadCount; i++) + { + int vIndex = i * 4; + // First triangle + buffer.putShort((short) (vIndex)); + buffer.putShort((short) (vIndex + 1)); + buffer.putShort((short) (vIndex + 2)); + // Second triangle + buffer.putShort((short) (vIndex + 2)); + buffer.putShort((short) (vIndex + 3)); + buffer.putShort((short) (vIndex)); + } + if (buffer.hasRemaining()) + { + throw new IllegalStateException("QuadElementBuffer is not full somehow after building"); + } + buffer.rewind(); + } + private static void buildBufferInt(int quadCount, ByteBuffer buffer) + { + for (int i = 0; i < quadCount; i++) + { + int vIndex = i * 4; + // First triangle + buffer.putInt(vIndex); + buffer.putInt(vIndex + 1); + buffer.putInt(vIndex + 2); + // Second triangle + buffer.putInt(vIndex + 2); + buffer.putInt(vIndex + 3); + buffer.putInt(vIndex); + } + if (buffer.hasRemaining()) + { + throw new IllegalStateException("QuadElementBuffer is not full somehow after building"); + } + buffer.rewind(); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java new file mode 100644 index 000000000..cd2174386 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java @@ -0,0 +1,184 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.shader; + +import java.io.BufferedReader; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.ByteBuffer; + +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import org.lwjgl.PointerBuffer; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL32C; +import org.lwjgl.system.MemoryStack; +import org.lwjgl.system.MemoryUtil; +import org.lwjgl.system.NativeType; + +/** + * This object holds a OpenGL reference to a shader + * and allows for reading in and compiling a shader file. + */ +public class Shader +{ + private static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) + .chatLevelConfig(Config.Common.Logging.logRendererGLEventToChat) + .build(); + + + /** OpenGL shader ID */ + public final int id; + + + + //==============// + // constructors // + //==============// + //region + + /** + * Creates a shader with specified type. + * + * @param type Either GL_VERTEX_SHADER or GL_FRAGMENT_SHADER. + * @param sourceString File path of the shader + * @throws RuntimeException if the shader fails to compile + */ + public Shader(int type, String sourceString) + { + LOGGER.info("Loading shader with type: ["+type+"]"); + LOGGER.debug("Source: \n["+sourceString+"]"); + if (sourceString == null || sourceString.isEmpty()) + { + throw new IllegalArgumentException("No shader source given."); + } + + // Create an empty shader object + this.id = GL32.glCreateShader(type); + if (this.id == 0) + { + throw new IllegalArgumentException("Failed to create shader with type ["+type+"] and Source: \n["+sourceString+"]."); + } + + safeShaderSource(this.id, sourceString); + GL32.glCompileShader(this.id); + // check if the shader compiled + int status = GL32.glGetShaderi(this.id, GL32.GL_COMPILE_STATUS); + if (status != GL32.GL_TRUE) + { + + String message = "Shader compiler error. Details: [" + GL32.glGetShaderInfoLog(this.id) + "]\n"; + message += "Source: \n[" + sourceString + "]"; + this.free(); // important! + throw new RuntimeException(message); + } + LOGGER.info("Shader loaded sucessfully."); + } + + //endregion + + + + //=========// + // helpers // + //=========// + //region + + /** + * Identical in function to {@link GL32C#glShaderSource(int, CharSequence)} but + * passes a null pointer for string length to force the driver to rely on the null + * terminator for string length. This is a workaround for an apparent flaw with some + * AMD drivers that don't receive or interpret the length correctly, resulting in + * an access violation when the driver tries to read past the string memory. + * + *

Hat tip to fewizz for the find and the fix. + * + *

Source: https://github.com/vram-guild/canvas/commit/820bf754092ccaf8d0c169620c2ff575722d7d96 + */ + private static void safeShaderSource(@NativeType("GLuint") int glId, @NativeType("GLchar const **") CharSequence source) + { + final MemoryStack stack = MemoryStack.stackGet(); + final int stackPointer = stack.getPointer(); + + try + { + final ByteBuffer sourceBuffer = MemoryUtil.memUTF8(source, true); + final PointerBuffer pointers = stack.mallocPointer(1); + pointers.put(sourceBuffer); + + GL32.nglShaderSource(glId, 1, pointers.address0(), 0); + org.lwjgl.system.APIUtil.apiArrayFree(pointers.address0(), 1); + } + finally + { + stack.setPointer(stackPointer); + } + } + + public void free() { GL32.glDeleteShader(this.id); } + + public static String loadFile(String path, boolean absoluteFilePath) + { + StringBuilder stringBuilder = new StringBuilder(); + + try + { + // open the file + InputStream in; + if (absoluteFilePath) + { + // Throws FileNotFoundException + in = new FileInputStream(path); // Note: this should use OS path seperator + } + else + { + in = Shader.class.getClassLoader().getResourceAsStream(path); // Note: path seperator should be '/' + if (in == null) + { + throw new FileNotFoundException("Shader file not found in resource: " + path); + } + } + BufferedReader reader = new BufferedReader(new InputStreamReader(in)); + + // read in the file + String line; + while ((line = reader.readLine()) != null) + { + stringBuilder.append(line).append("\n"); + } + } + catch (IOException e) + { + throw new RuntimeException("Unable to load shader from file [" + path + "]. Error: " + e.getMessage()); + } + + return stringBuilder.toString(); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java new file mode 100644 index 000000000..97ef510f4 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java @@ -0,0 +1,225 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.shader; + +import java.awt.Color; +import java.nio.FloatBuffer; + +import com.seibel.distanthorizons.api.objects.math.DhApiVec3i; +import org.lwjgl.opengl.GL32; +import org.lwjgl.system.MemoryStack; + +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3f; + + +/** + * This object holds the reference to a OpenGL shader program + * and contains a few methods that can be used with OpenGL shader programs. + * The reason for many of these simple wrapper methods is as reminders of what + * can (and needs to be) done with a shader program. + */ +public class ShaderProgram +{ + /** Stores the handle of the program. */ + public final int id; + + + + //=============// + // constructor // + //=============// + //region + + public ShaderProgram(String vertResourcePath, String fragResourcePath, String attribute) { this(vertResourcePath, fragResourcePath, new String[]{ attribute }); } + /** + * @param vertResourcePath the relative path the vertex shader should be found + * @param fragResourcePath the relative path the fragment shader should be found + */ + public ShaderProgram(String vertResourcePath, String fragResourcePath, String[] attributes) + { + this.id = GL32.glCreateProgram(); + + { + String shaderString = Shader.loadFile(vertResourcePath, false); + Shader vertShader = new Shader(GL32.GL_VERTEX_SHADER, shaderString); + GL32.glAttachShader(this.id, vertShader.id); + vertShader.free(); + } + + { + String shaderString = Shader.loadFile(fragResourcePath, false); + Shader fragShader = new Shader(GL32.GL_FRAGMENT_SHADER, shaderString); + GL32.glAttachShader(this.id, fragShader.id); + fragShader.free(); + } + + for (int i = 0; i < attributes.length; i++) + { + GL32.glBindAttribLocation(this.id, i, attributes[i]); + } + GL32.glLinkProgram(this.id); + + int status = GL32.glGetProgrami(this.id, GL32.GL_LINK_STATUS); + if (status != GL32.GL_TRUE) + { + String message = "Shader Link Error. Details: " + GL32.glGetProgramInfoLog(this.id); + this.free(); // important! + throw new RuntimeException(message); + } + GL32.glUseProgram(this.id); // This HAVE to be a direct call to prevent calling the overloaded version + } + + //endregion + + + + //=========// + // binding // + //=========// + //region + + public void bind() { GL32.glUseProgram(this.id); } + public void unbind() { GL32.glUseProgram(0); } + + public void free() { GL32.glDeleteProgram(this.id); } + + //endregion + + + + //============// + // attributes // + //============// + //region + + /** + * WARNING: Slow native call! Cache it if possible! + * Gets the location of an attribute variable with specified name. + * Calls GL20.glGetAttribLocation(id, name) + * + * @param name Attribute name + * @return Location of the attribute + * @throws RuntimeException if attribute not found + */ + public int getAttributeLocation(CharSequence name) + { + int i = GL32.glGetAttribLocation(id, name); + if (i == -1) throw new RuntimeException("Attribute name not found: " + name); + return i; + } + /** + * Same as above but without throwing errors.
+ * Returns -1 if the attribute doesn't exist or has been optimized out. + */ + public int tryGetAttributeLocation(CharSequence name) + { return GL32.glGetAttribLocation(this.id, name); } + + //endregion + + + + //==========// + // uniforms // + //==========// + //region + + /** + * WARNING: Slow native call! Cache it if possible! + * Gets the location of a uniform variable with specified name. + * Calls GL20.glGetUniformLocation(id, name) + * + * @param name Uniform name + * @return Location of the Uniform + * @throws RuntimeException if uniform not found + */ + public int getUniformLocation(CharSequence name) throws RuntimeException + { + int i = GL32.glGetUniformLocation(id, name); + if (i == -1) + { + throw new RuntimeException("Uniform name not found: " + name); + } + return i; + } + + // Same as above but without throwing errors. + // Return -1 if uniform doesn't exist or has been optimized out + public int tryGetUniformLocation(CharSequence name) + { return GL32.glGetUniformLocation(this.id, name); } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, boolean value) { GL32.glUniform1i(location, value ? 1 : 0); } + /** @see ShaderProgram#setUniform(int, boolean) */ + public void trySetUniform(int location, boolean value) { if (location != -1) { this.setUniform(location, value); } } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, int value) { GL32.glUniform1i(location, value); } + /** @see ShaderProgram#setUniform(int, int) */ + public void trySetUniform(int location, int value) { if (location != -1) { this.setUniform(location, value); } } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, float value) { GL32.glUniform1f(location, value); } + /** @see ShaderProgram#setUniform(int, float) */ + public void trySetUniform(int location, float value) { if (location != -1) { this.setUniform(location, value); } } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, Vec3f value) { GL32.glUniform3f(location, value.x, value.y, value.z); } + /** @see ShaderProgram#setUniform(int, Vec3f) */ + public void trySetUniform(int location, Vec3f value) { if (location != -1) { this.setUniform(location, value); } } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, DhApiVec3i value) { GL32.glUniform3i(location, value.x, value.y, value.z); } + /** @see ShaderProgram#setUniform(int, Mat4f) */ + public void trySetUniform(int location, DhApiVec3i value) { if (location != -1) { this.setUniform(location, value); } } + + /** Requires a bound ShaderProgram. */ + public void setUniform(int location, Mat4f value) + { + try (MemoryStack stack = MemoryStack.stackPush()) + { + FloatBuffer buffer = stack.mallocFloat(4 * 4); + value.store(buffer); + GL32.glUniformMatrix4fv(location, false, buffer); + } + } + /** @see ShaderProgram#setUniform(int, Mat4f) */ + public void trySetUniform(int location, Mat4f value) { if (location != -1) { this.setUniform(location, value); } } + + /** + * Converts the color's RGBA values into values between 0 and 1.
+ * Requires a bound ShaderProgram. + */ + public void setUniform(int location, Color value) + { + GL32.glUniform4f(location, + value.getRed() / 256.0f, + value.getGreen() / 256.0f, + value.getBlue() / 256.0f, + value.getAlpha() / 256.0f); + } + /** @see ShaderProgram#setUniform(int, Color) */ + public void trySetUniform(int location, Color value) { if (location != -1) { this.setUniform(location, value); } } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java new file mode 100644 index 000000000..f687f7941 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java @@ -0,0 +1,62 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL13C; +import org.lwjgl.opengl.GL43C; + +import java.nio.ByteBuffer; + +public class DHDepthTexture +{ + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private int id; + public DHDepthTexture(int width, int height, EDhDepthBufferFormat format) + { + this.id = GL43C.glGenTextures(); + + this.resize(width, height, format); + + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_MIN_FILTER, GL11C.GL_NEAREST); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_MAG_FILTER, GL11C.GL_NEAREST); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_WRAP_S, GL13C.GL_CLAMP_TO_EDGE); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_WRAP_T, GL13C.GL_CLAMP_TO_EDGE); + + // disable mip-mapping since DH is just going to draw straight to the screen + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_BASE_LEVEL, 0); + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_MAX_LEVEL, 0); + + GL43C.glBindTexture(GL43C.GL_TEXTURE_2D, 0); + } + + // For internal use by Iris for copying data. Do not use this in DH. + public DHDepthTexture(int id) { this.id = id; } + + public void resize(int width, int height, EDhDepthBufferFormat format) + { + GL43C.glBindTexture(GL43C.GL_TEXTURE_2D, this.getTextureId()); + GL43C.glTexImage2D(GL11C.GL_TEXTURE_2D, 0, format.getGlInternalFormat(), width, height, 0, + format.getGlType(), format.getGlFormat(), (ByteBuffer) null); + } + + public int getTextureId() + { + if (this.id == -1) + { + throw new IllegalStateException("Depth texture does not exist!"); + } + + return this.id; + } + + public void destroy() + { + GLMC.glDeleteTextures(this.getTextureId()); + this.id = -1; + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java new file mode 100644 index 000000000..4b4a8cf1b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java @@ -0,0 +1,183 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import org.joml.Vector2i; +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL13C; +import org.lwjgl.opengl.GL43C; + +import java.nio.ByteBuffer; + +public class DhColorTexture +{ + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private final EDhInternalTextureFormat internalFormat; + private final EDhPixelFormat format; + private final EDhPixelType type; + private int width; + private int height; + + private boolean isValid; + /** AKA, the OpenGL name of this texture */ + private final int id; + + private static final ByteBuffer NULL_BUFFER = null; + + + + //=============// + // constructor // + //=============// + + public DhColorTexture(Builder builder) + { + this.isValid = true; + + this.internalFormat = builder.internalFormat; + this.format = builder.format; + this.type = builder.type; + + this.width = builder.width; + this.height = builder.height; + + this.id = GL43C.glGenTextures(); + + boolean isPixelFormatInteger = builder.internalFormat.getPixelFormat().isInteger(); + this.setupTexture(this.id, builder.width, builder.height, !isPixelFormatInteger); // this binds the texture + + // Clean up after ourselves + // This is strictly defensive to ensure that other buggy code doesn't tamper with our textures + GL43C.glBindTexture(GL43C.GL_TEXTURE_2D, 0); + } + + + + //=========// + // methods // + //=========// + + private void setupTexture(int id, int width, int height, boolean allowsLinear) + { + this.resizeTexture(id, width, height); + + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_MIN_FILTER, allowsLinear ? GL11C.GL_LINEAR : GL11C.GL_NEAREST); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_MAG_FILTER, allowsLinear ? GL11C.GL_LINEAR : GL11C.GL_NEAREST); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_WRAP_S, GL13C.GL_CLAMP_TO_EDGE); + GL43C.glTexParameteri(GL11C.GL_TEXTURE_2D, GL11C.GL_TEXTURE_WRAP_T, GL13C.GL_CLAMP_TO_EDGE); + + // disable mip-mapping since DH is just going to draw straight to the screen + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_BASE_LEVEL, 0); + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_MAX_LEVEL, 0); + } + + private void resizeTexture(int texture, int width, int height) + { + GL43C.glBindTexture(GL43C.GL_TEXTURE_2D, texture); + GL43C.glTexImage2D(GL11C.GL_TEXTURE_2D, 0, this.internalFormat.getGlFormat(), width, height, 0, this.format.getGlFormat(), this.type.getGlFormat(), NULL_BUFFER); + } + + void resize(Vector2i textureScaleOverride) { this.resize(textureScaleOverride.x, textureScaleOverride.y); } + + // Package private, call CompositeRenderTargets#resizeIfNeeded instead. + public void resize(int width, int height) + { + this.throwIfInvalid(); + + this.width = width; + this.height = height; + + this.resizeTexture(this.id, width, height); + } + + public EDhInternalTextureFormat getInternalFormat() { return this.internalFormat; } + + public int getTextureId() + { + this.throwIfInvalid(); + return this.id; + } + + public int getWidth() { return this.width; } + + public int getHeight() { return this.height; } + + public void destroy() + { + this.throwIfInvalid(); + this.isValid = false; + + GLMC.glDeleteTextures(this.id); + } + + /** @throws IllegalStateException if the texture isn't valid */ + private void throwIfInvalid() + { + if (!this.isValid) + { + throw new IllegalStateException("Attempted to use a deleted composite render target"); + } + } + + public static Builder builder() { return new Builder(); } + + + + //================// + // helper classes // + //================// + + public static class Builder + { + private EDhInternalTextureFormat internalFormat = EDhInternalTextureFormat.RGBA8; + private int width = 0; + private int height = 0; + private EDhPixelFormat format = EDhPixelFormat.RGBA; + private EDhPixelType type = EDhPixelType.UNSIGNED_BYTE; + + private Builder() + { + // No-op + } + + public Builder setInternalFormat(EDhInternalTextureFormat format) + { + this.internalFormat = format; + return this; + } + + public Builder setDimensions(int width, int height) + { + if (width <= 0) + { + throw new IllegalArgumentException("Width must be greater than zero"); + } + + if (height <= 0) + { + throw new IllegalArgumentException("Height must be greater than zero"); + } + + this.width = width; + this.height = height; + + return this; + } + + public Builder setPixelFormat(EDhPixelFormat pixelFormat) + { + this.format = pixelFormat; + return this; + } + + public Builder setPixelType(EDhPixelType pixelType) + { + this.type = pixelType; + return this; + } + + public DhColorTexture build() { return new DhColorTexture(this); } + + } +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java new file mode 100644 index 000000000..2c6bc961b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java @@ -0,0 +1,152 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import it.unimi.dsi.fastutil.ints.Int2IntArrayMap; +import it.unimi.dsi.fastutil.ints.Int2IntMap; +import org.lwjgl.opengl.GL32; + +public class DhFramebuffer implements IDhApiFramebuffer +{ + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + private final Int2IntMap attachments; + private final int maxDrawBuffers; + private final int maxColorAttachments; + private boolean hasDepthAttachment; + private int id; + + + + //=============// + // constructor // + //=============// + + public DhFramebuffer() + { + this.id = GL32.glGenFramebuffers(); + + this.attachments = new Int2IntArrayMap(); + this.maxDrawBuffers = GL32.glGetInteger(GL32.GL_MAX_DRAW_BUFFERS); + this.maxColorAttachments = GL32.glGetInteger(GL32.GL_MAX_COLOR_ATTACHMENTS); + this.hasDepthAttachment = false; + } + + /** For internal use by Iris, do not remove. */ + public DhFramebuffer(int id) + { + this.id = id; + + this.attachments = new Int2IntArrayMap(); + this.maxDrawBuffers = GL32.glGetInteger(GL32.GL_MAX_DRAW_BUFFERS); + this.maxColorAttachments = GL32.glGetInteger(GL32.GL_MAX_COLOR_ATTACHMENTS); + this.hasDepthAttachment = false; + } + + + + //=========// + // methods // + //=========// + + @Override + public void addDepthAttachment(int textureId, boolean isCombinedStencil) + { + this.bind(); + + int depthAttachment = isCombinedStencil ? GL32.GL_DEPTH_STENCIL_ATTACHMENT : GL32.GL_DEPTH_ATTACHMENT; + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, depthAttachment, GL32.GL_TEXTURE_2D, textureId, 0); + + this.hasDepthAttachment = true; + } + + @Override + public void addColorAttachment(int textureIndex, int textureId) + { + this.bind(); + + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0 + textureIndex, GL32.GL_TEXTURE_2D, textureId, 0); + this.attachments.put(textureIndex, textureId); + } + + public void noDrawBuffers() + { + this.bind(); + GL32.glDrawBuffers(new int[]{GL32.GL_NONE}); + } + + public void drawBuffers(int[] buffers) + { + int[] glBuffers = new int[buffers.length]; + int index = 0; + + if (buffers.length > this.maxDrawBuffers) + { + throw new IllegalArgumentException("Cannot write to more than " + this.maxDrawBuffers + " draw buffers on this GPU"); + } + + for (int buffer : buffers) + { + if (buffer >= this.maxColorAttachments) + { + throw new IllegalArgumentException("Only " + this.maxColorAttachments + " color attachments are supported on this GPU, but an attempt was made to write to a color attachment with index " + buffer); + } + + glBuffers[index++] = GL32.GL_COLOR_ATTACHMENT0 + buffer; + } + + this.bind(); + GL32.glDrawBuffers(new int[]{GL32.GL_NONE}); + } + + public void readBuffer(int buffer) + { + this.bind(); + GL32.glReadBuffer(GL32.GL_COLOR_ATTACHMENT0 + buffer); + } + + public int getColorAttachment(int index) { return this.attachments.get(index); } + + public boolean hasDepthAttachment() { return this.hasDepthAttachment; } + + @Override + public void bind() + { + if (this.id == -1) + { + throw new IllegalStateException("Framebuffer does not exist!"); + } + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.id); + } + + public void bindAsReadBuffer() { GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, this.id); } + + public void bindAsDrawBuffer() { GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, this.id); } + + @Override + public void destroy() + { + GL32.glDeleteFramebuffers(this.id); + this.id = -1; + } + + @Override + public int getStatus() + { + this.bind(); + int status = GL32.glCheckFramebufferStatus(GL32.GL_FRAMEBUFFER); + return status; + } + + @Override + public int getId() { return this.id; } + + + + //=============// + // API methods // + //=============// + + public boolean overrideThisFrame() { return true; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java new file mode 100644 index 000000000..734f4bb25 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java @@ -0,0 +1,114 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL30C; +import org.lwjgl.opengl.GL43C; + +public enum EDhDepthBufferFormat +{ + DEPTH(false), + DEPTH16(false), + DEPTH24(false), + DEPTH32(false), + DEPTH32F(false), + DEPTH_STENCIL(true), + DEPTH24_STENCIL8(true), + DEPTH32F_STENCIL8(true); + + + + private final boolean combinedStencil; + + EDhDepthBufferFormat(boolean combinedStencil) { this.combinedStencil = combinedStencil; } + + + + @Nullable + public static EDhDepthBufferFormat fromGlEnum(int glenum) + { + switch (glenum) + { + case GL30C.GL_DEPTH_COMPONENT: + return EDhDepthBufferFormat.DEPTH; + case GL30C.GL_DEPTH_COMPONENT16: + return EDhDepthBufferFormat.DEPTH16; + case GL30C.GL_DEPTH_COMPONENT24: + return EDhDepthBufferFormat.DEPTH24; + case GL30C.GL_DEPTH_COMPONENT32: + return EDhDepthBufferFormat.DEPTH32; + case GL30C.GL_DEPTH_COMPONENT32F: + return EDhDepthBufferFormat.DEPTH32F; + case GL30C.GL_DEPTH_STENCIL: + return EDhDepthBufferFormat.DEPTH_STENCIL; + case GL30C.GL_DEPTH24_STENCIL8: + return EDhDepthBufferFormat.DEPTH24_STENCIL8; + case GL30C.GL_DEPTH32F_STENCIL8: + return EDhDepthBufferFormat.DEPTH32F_STENCIL8; + default: + return null; + } + } + + public static EDhDepthBufferFormat fromGlEnumOrDefault(int glenum) + { + EDhDepthBufferFormat format = fromGlEnum(glenum); + if (format == null) + { + // yolo, just assume it's GL_DEPTH_COMPONENT + return EDhDepthBufferFormat.DEPTH; + } + return format; + } + + public int getGlInternalFormat() + { + switch (this) + { + case DEPTH: + return GL30C.GL_DEPTH_COMPONENT; + case DEPTH16: + return GL30C.GL_DEPTH_COMPONENT16; + case DEPTH24: + return GL30C.GL_DEPTH_COMPONENT24; + case DEPTH32: + return GL30C.GL_DEPTH_COMPONENT32; + case DEPTH32F: + return GL30C.GL_DEPTH_COMPONENT32F; + case DEPTH_STENCIL: + return GL30C.GL_DEPTH_STENCIL; + case DEPTH24_STENCIL8: + return GL30C.GL_DEPTH24_STENCIL8; + case DEPTH32F_STENCIL8: + return GL30C.GL_DEPTH32F_STENCIL8; + } + + throw new AssertionError("unreachable"); + } + + public int getGlType() { return isCombinedStencil() ? GL30C.GL_DEPTH_STENCIL : GL30C.GL_DEPTH_COMPONENT; } + + public int getGlFormat() + { + switch (this) + { + case DEPTH: + case DEPTH16: + return GL43C.GL_UNSIGNED_SHORT; + case DEPTH24: + case DEPTH32: + return GL43C.GL_UNSIGNED_INT; + case DEPTH32F: + return GL30C.GL_FLOAT; + case DEPTH_STENCIL: + case DEPTH24_STENCIL8: + return GL30C.GL_UNSIGNED_INT_24_8; + case DEPTH32F_STENCIL8: + return GL30C.GL_FLOAT_32_UNSIGNED_INT_24_8_REV; + } + + throw new AssertionError("unreachable"); + } + + public boolean isCombinedStencil() { return combinedStencil; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java new file mode 100644 index 000000000..a9a4851fc --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java @@ -0,0 +1,130 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL30C; +import org.lwjgl.opengl.GL31C; + +import java.util.Locale; +import java.util.Optional; + +public enum EDhInternalTextureFormat +{ + RGBA(GL11C.GL_RGBA, EGlVersion.GL_11, EDhPixelFormat.RGBA), + + // 8-bit normalized + R8(GL30C.GL_R8, EGlVersion.GL_30, EDhPixelFormat.RED), + RG8(GL30C.GL_RG8, EGlVersion.GL_30, EDhPixelFormat.RG), + RGB8(GL11C.GL_RGB8, EGlVersion.GL_11, EDhPixelFormat.RGB), + RGBA8(GL11C.GL_RGBA8, EGlVersion.GL_11, EDhPixelFormat.RGBA), + + // 8-bit signed normalized + R8_SNORM(GL31C.GL_R8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RED), + RG8_SNORM(GL31C.GL_RG8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RG), + RGB8_SNORM(GL31C.GL_RGB8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGB), + RGBA8_SNORM(GL31C.GL_RGBA8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGBA), + + // 16-bit normalized + R16(GL30C.GL_R16, EGlVersion.GL_30, EDhPixelFormat.RED), + RG16(GL30C.GL_RG16, EGlVersion.GL_30, EDhPixelFormat.RG), + RGB16(GL11C.GL_RGB16, EGlVersion.GL_11, EDhPixelFormat.RGB), + RGBA16(GL11C.GL_RGBA16, EGlVersion.GL_11, EDhPixelFormat.RGBA), + + // 16-bit signed normalized + R16_SNORM(GL31C.GL_R16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RED), + RG16_SNORM(GL31C.GL_RG16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RG), + RGB16_SNORM(GL31C.GL_RGB16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGB), + RGBA16_SNORM(GL31C.GL_RGBA16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGBA), + + // 16-bit float + R16F(GL30C.GL_R16F, EGlVersion.GL_30, EDhPixelFormat.RED), + RG16F(GL30C.GL_RG16F, EGlVersion.GL_30, EDhPixelFormat.RG), + RGB16F(GL30C.GL_RGB16F, EGlVersion.GL_30, EDhPixelFormat.RGB), + RGBA16F(GL30C.GL_RGBA16F, EGlVersion.GL_30, EDhPixelFormat.RGBA), + + // 32-bit float + R32F(GL30C.GL_R32F, EGlVersion.GL_30, EDhPixelFormat.RED), + RG32F(GL30C.GL_RG32F, EGlVersion.GL_30, EDhPixelFormat.RG), + RGB32F(GL30C.GL_RGB32F, EGlVersion.GL_30, EDhPixelFormat.RGB), + RGBA32F(GL30C.GL_RGBA32F, EGlVersion.GL_30, EDhPixelFormat.RGBA), + + // 8-bit integer + R8I(GL30C.GL_R8I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG8I(GL30C.GL_RG8I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB8I(GL30C.GL_RGB8I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA8I(GL30C.GL_RGBA8I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // 8-bit unsigned integer + R8UI(GL30C.GL_R8UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG8UI(GL30C.GL_RG8UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB8UI(GL30C.GL_RGB8UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA8UI(GL30C.GL_RGBA8UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // 16-bit integer + R16I(GL30C.GL_R16I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG16I(GL30C.GL_RG16I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB16I(GL30C.GL_RGB16I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA16I(GL30C.GL_RGBA16I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // 16-bit unsigned integer + R16UI(GL30C.GL_R16UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG16UI(GL30C.GL_RG16UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB16UI(GL30C.GL_RGB16UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA16UI(GL30C.GL_RGBA16UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // 32-bit integer + R32I(GL30C.GL_R32I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG32I(GL30C.GL_RG32I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB32I(GL30C.GL_RGB32I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA32I(GL30C.GL_RGBA32I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // 32-bit unsigned integer + R32UI(GL30C.GL_R32UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), + RG32UI(GL30C.GL_RG32UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), + RGB32UI(GL30C.GL_RGB32UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), + RGBA32UI(GL30C.GL_RGBA32UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), + + // Mixed + R3_G3_B2(GL11C.GL_R3_G3_B2, EGlVersion.GL_11, EDhPixelFormat.RGB), + RGB5_A1(GL11C.GL_RGB5_A1, EGlVersion.GL_11, EDhPixelFormat.RGBA), + RGB10_A2(GL11C.GL_RGB10_A2, EGlVersion.GL_11, EDhPixelFormat.RGBA), + R11F_G11F_B10F(GL30C.GL_R11F_G11F_B10F, EGlVersion.GL_30, EDhPixelFormat.RGB), + RGB9_E5(GL30C.GL_RGB9_E5, EGlVersion.GL_30, EDhPixelFormat.RGB); + + + + private final int glFormat; + private final EGlVersion minimumGlVersion; + private final EDhPixelFormat expectedPixelFormat; + + + + EDhInternalTextureFormat(int glFormat, EGlVersion minimumGlVersion, EDhPixelFormat expectedPixelFormat) + { + this.glFormat = glFormat; + this.minimumGlVersion = minimumGlVersion; + this.expectedPixelFormat = expectedPixelFormat; + } + + + + public static Optional fromString(String name) + { + try + { + return Optional.of(EDhInternalTextureFormat.valueOf(name.toUpperCase(Locale.US))); + } + catch (IllegalArgumentException e) + { + return Optional.empty(); + } + } + + public int getGlFormat() { return this.glFormat; } + + public EDhPixelFormat getPixelFormat() { return this.expectedPixelFormat; } + + public EGlVersion getMinimumGlVersion() { return this.minimumGlVersion; } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java new file mode 100644 index 000000000..8427e62ea --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java @@ -0,0 +1,60 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL12C; +import org.lwjgl.opengl.GL30C; + +import java.util.Locale; +import java.util.Optional; + +public enum EDhPixelFormat +{ + RED(GL11C.GL_RED, EGlVersion.GL_11, false), + RG(GL30C.GL_RG, EGlVersion.GL_30, false), + RGB(GL11C.GL_RGB, EGlVersion.GL_11, false), + BGR(GL12C.GL_BGR, EGlVersion.GL_12, false), + RGBA(GL11C.GL_RGBA, EGlVersion.GL_11, false), + BGRA(GL12C.GL_BGRA, EGlVersion.GL_12, false), + RED_INTEGER(GL30C.GL_RED_INTEGER, EGlVersion.GL_30, true), + RG_INTEGER(GL30C.GL_RG_INTEGER, EGlVersion.GL_30, true), + RGB_INTEGER(GL30C.GL_RGB_INTEGER, EGlVersion.GL_30, true), + BGR_INTEGER(GL30C.GL_BGR_INTEGER, EGlVersion.GL_30, true), + RGBA_INTEGER(GL30C.GL_RGBA_INTEGER, EGlVersion.GL_30, true), + BGRA_INTEGER(GL30C.GL_BGRA_INTEGER, EGlVersion.GL_30, true); + + + + private final int glFormat; + private final EGlVersion minimumGlVersion; + private final boolean isInteger; + + + + EDhPixelFormat(int glFormat, EGlVersion minimumGlVersion, boolean isInteger) + { + this.glFormat = glFormat; + this.minimumGlVersion = minimumGlVersion; + this.isInteger = isInteger; + } + + + + public static Optional fromString(String name) + { + try + { + return Optional.of(EDhPixelFormat.valueOf(name.toUpperCase(Locale.US))); + } + catch (IllegalArgumentException e) + { + return Optional.empty(); + } + } + + public int getGlFormat() { return this.glFormat; } + + public EGlVersion getMinimumGlVersion() { return this.minimumGlVersion; } + + public boolean isInteger() { return this.isInteger; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java new file mode 100644 index 000000000..5d3c5d176 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java @@ -0,0 +1,64 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL12C; +import org.lwjgl.opengl.GL30C; + +import java.util.Locale; +import java.util.Optional; + +public enum EDhPixelType +{ + BYTE(GL11C.GL_BYTE, EGlVersion.GL_11), + SHORT(GL11C.GL_SHORT, EGlVersion.GL_11), + INT(GL11C.GL_INT, EGlVersion.GL_11), + HALF_FLOAT(GL30C.GL_HALF_FLOAT, EGlVersion.GL_30), + FLOAT(GL11C.GL_FLOAT, EGlVersion.GL_11), + UNSIGNED_BYTE(GL11C.GL_UNSIGNED_BYTE, EGlVersion.GL_11), + UNSIGNED_BYTE_3_3_2(GL12C.GL_UNSIGNED_BYTE_3_3_2, EGlVersion.GL_12), + UNSIGNED_BYTE_2_3_3_REV(GL12C.GL_UNSIGNED_BYTE_2_3_3_REV, EGlVersion.GL_12), + UNSIGNED_SHORT(GL11C.GL_UNSIGNED_SHORT, EGlVersion.GL_11), + UNSIGNED_SHORT_5_6_5(GL12C.GL_UNSIGNED_SHORT_5_6_5, EGlVersion.GL_12), + UNSIGNED_SHORT_5_6_5_REV(GL12C.GL_UNSIGNED_SHORT_5_6_5_REV, EGlVersion.GL_12), + UNSIGNED_SHORT_4_4_4_4(GL12C.GL_UNSIGNED_SHORT_4_4_4_4, EGlVersion.GL_12), + UNSIGNED_SHORT_4_4_4_4_REV(GL12C.GL_UNSIGNED_SHORT_4_4_4_4_REV, EGlVersion.GL_12), + UNSIGNED_SHORT_5_5_5_1(GL12C.GL_UNSIGNED_SHORT_5_5_5_1, EGlVersion.GL_12), + UNSIGNED_SHORT_1_5_5_5_REV(GL12C.GL_UNSIGNED_SHORT_1_5_5_5_REV, EGlVersion.GL_12), + UNSIGNED_INT(GL11C.GL_UNSIGNED_INT, EGlVersion.GL_11), + UNSIGNED_INT_8_8_8_8(GL12C.GL_UNSIGNED_INT_8_8_8_8, EGlVersion.GL_12), + UNSIGNED_INT_8_8_8_8_REV(GL12C.GL_UNSIGNED_INT_8_8_8_8_REV, EGlVersion.GL_12), + UNSIGNED_INT_10_10_10_2(GL12C.GL_UNSIGNED_INT_10_10_10_2, EGlVersion.GL_12), + UNSIGNED_INT_2_10_10_10_REV(GL12C.GL_UNSIGNED_INT_2_10_10_10_REV, EGlVersion.GL_12); + + + + private final int glFormat; + private final EGlVersion minimumGlVersion; + + + + EDhPixelType(int glFormat, EGlVersion minimumGlVersion) + { + this.glFormat = glFormat; + this.minimumGlVersion = minimumGlVersion; + } + + + + public static Optional fromString(String name) + { + try + { + return Optional.of(EDhPixelType.valueOf(name.toUpperCase(Locale.US))); + } + catch (IllegalArgumentException e) + { + return Optional.empty(); + } + } + + public int getGlFormat() { return glFormat; } + + public EGlVersion getMinimumGlVersion() { return minimumGlVersion; } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java new file mode 100644 index 000000000..6a256d2d3 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java @@ -0,0 +1,9 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; + +public enum EGlVersion +{ + GL_11, + GL_12, + GL_30, + GL_31 +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java new file mode 100644 index 000000000..224ad8b0b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java @@ -0,0 +1,92 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import org.lwjgl.opengl.GL32; + +/** + * Base for binding/unbinding Vertex Attribute objects (VAO's). + * + * @see VertexAttributePostGL43 + * @see VertexAttributePreGL43 + */ +public abstract class AbstractVertexAttribute +{ + /** Stores the handle of the AbstractVertexAttribute. */ + public final int id; + + + + //==============// + // constructors // + //==============// + + // This will bind AbstractVertexAttribute + protected AbstractVertexAttribute() + { + this.id = GL32.glGenVertexArrays(); + GL32.glBindVertexArray(this.id); + } + + public static AbstractVertexAttribute create() + { + if (GLProxy.getInstance().vertexAttributeBufferBindingSupported) + { + return new VertexAttributePostGL43(); + } + else + { + return new VertexAttributePreGL43(); + } + } + + + + //=========// + // binding // + //=========// + + public void bind() { GL32.glBindVertexArray(this.id); } + public void unbind() { GL32.glBindVertexArray(0); } + + /** Always remember to always free your resources! */ + public void free() { GL32.glDeleteVertexArrays(this.id); } + + + + //==================// + // abstract methods // + //==================// + + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + public abstract void bindBufferToAllBindingPoints(int buffer); + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + public abstract void bindBufferToBindingPoint(int buffer, int bindingPoint); + /** Requires both AbstractVertexAttribute to be bound */ + public abstract void unbindBuffersFromAllBindingPoint(); + /** Requires both AbstractVertexAttribute to be bound */ + public abstract void unbindBuffersFromBindingPoint(int bindingPoint); + /** Requires both AbstractVertexAttribute to be bound */ + public abstract void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute); + /** Requires both AbstractVertexAttribute to be bound */ + public abstract void completeAndCheck(int expectedStrideSize); + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java new file mode 100644 index 000000000..7733fbf50 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java @@ -0,0 +1,155 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; + +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import org.lwjgl.opengl.GL43; + +/** + * In OpenGL 4.3 and later, Vertex Attribute got a make-over. + * Now it provides support for buffer binding points natively. + * This means that setting up the VAO is just use ONE native call when + * binding to a buffer.

+ * + * Since I no longer need to implement binding points, I also no + * longer needs to keep track of Pointers. + */ +public final class VertexAttributePostGL43 extends AbstractVertexAttribute +{ + private static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) + .chatLevelConfig(Config.Common.Logging.logRendererGLEventToChat) + .build(); + + + int numberOfBindingPoints = 0; + int strideSize = 0; + + + + //=============// + // constructor // + //=============// + + /** This will bind the {@link AbstractVertexAttribute} */ + public VertexAttributePostGL43() + { + super(); // also bind AbstractVertexAttribute + } + + + + //=========// + // binding // + //=========// + + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + @Override + public void bindBufferToAllBindingPoints(int buffer) + { + for (int i = 0; i < this.numberOfBindingPoints; i++) + { + GL43.glBindVertexBuffer(i, buffer, 0, this.strideSize); + } + } + + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + @Override + public void bindBufferToBindingPoint(int buffer, int bindingPoint) + { + GL43.glBindVertexBuffer(bindingPoint, buffer, 0, this.strideSize); + } + + + + //===========// + // unbinding // + //===========// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void unbindBuffersFromAllBindingPoint() + { + for (int i = 0; i < this.numberOfBindingPoints; i++) + { + GL43.glBindVertexBuffer(i, 0, 0, 0); + } + } + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void unbindBuffersFromBindingPoint(int bindingPoint) + { + GL43.glBindVertexBuffer(bindingPoint, 0, 0, 0); + } + + + + //==========================// + // manual attribute setting // + //==========================// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute) + { + if (attribute.useInteger) + { + GL43.glVertexAttribIFormat(attributeIndex, attribute.elementCount, attribute.glType, this.strideSize); + } + else + { + GL43.glVertexAttribFormat(attributeIndex, attribute.elementCount, attribute.glType, + attribute.normalized, this.strideSize); // Here strideSize is new attrib offset + } + + this.strideSize += attribute.byteSize; + if (this.numberOfBindingPoints <= bindingPoint) + { + this.numberOfBindingPoints = bindingPoint + 1; + } + GL43.glVertexAttribBinding(attributeIndex, bindingPoint); + GL43.glEnableVertexAttribArray(attributeIndex); + } + + + + //============// + // validation // + //============// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void completeAndCheck(int expectedStrideSize) + { + if (this.strideSize != expectedStrideSize) + { + LOGGER.error("Vertex Attribute calculated stride size " + this.strideSize + + " does not match the provided expected stride size " + expectedStrideSize + "!"); + throw new IllegalArgumentException("Vertex Attribute Incorrect Format"); + } + + LOGGER.info("Vertex Attribute (GL43+) completed. It contains " + this.numberOfBindingPoints + + " binding points and a stride size of " + this.strideSize); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java new file mode 100644 index 000000000..5c18b2b13 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java @@ -0,0 +1,253 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.TreeMap; +import java.util.TreeSet; + +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import org.lwjgl.opengl.GL32; + + +public final class VertexAttributePreGL43 extends AbstractVertexAttribute +{ + private static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) + .chatLevelConfig(Config.Common.Logging.logRendererGLEventToChat) + .build(); + + + // I tried to use raw arrays as much as possible since those lookups + // happen every frame, and the speed directly affects fps + int strideSize = 0; + int[][] bindingPointsToIndex; + VertexPointer[] pointers; + int[] pointersOffset; + + TreeMap> bindingPointsToIndexBuilder; + ArrayList pointersBuilder; + + + + //=============// + // constructor // + //=============// + + /** This will bind the {@link AbstractVertexAttribute} */ + public VertexAttributePreGL43() + { + super(); // also bind AbstractVertexAttribute + this.bindingPointsToIndexBuilder = new TreeMap<>(); + this.pointersBuilder = new ArrayList<>(); + } + + + + //=========// + // binding // + //=========// + + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + @Override + public void bindBufferToAllBindingPoints(int buffer) + { + for (int i = 0; i < this.pointers.length; i++) + { + GL32.glEnableVertexAttribArray(i); + } + + for (int i = 0; i < this.pointers.length; i++) + { + VertexPointer pointer = this.pointers[i]; + if (pointer == null) + { + continue; + } + + if (pointer.useInteger) + { + GL32.glVertexAttribIPointer(i, pointer.elementCount, pointer.glType, + this.strideSize, this.pointersOffset[i]); + } + else + { + GL32.glVertexAttribPointer(i, pointer.elementCount, pointer.glType, + pointer.normalized, this.strideSize, this.pointersOffset[i]); + } + } + } + + /** Requires both AbstractVertexAttribute and VertexBuffer to be bound */ + @Override + public void bindBufferToBindingPoint(int buffer, int bindingPoint) + { + int[] bindingPointIndexes = this.bindingPointsToIndex[bindingPoint]; + + for (int bindingPointIndex : bindingPointIndexes) + { + GL32.glEnableVertexAttribArray(bindingPointIndex); + } + + for (int bindingPointIndex : bindingPointIndexes) + { + VertexPointer pointer = this.pointers[bindingPointIndex]; + if (pointer == null) + { + continue; + } + + if (pointer.useInteger) + { + GL32.glVertexAttribIPointer(bindingPointIndex, pointer.elementCount, pointer.glType, + this.strideSize, this.pointersOffset[bindingPointIndex]); + } + else + { + GL32.glVertexAttribPointer(bindingPointIndex, pointer.elementCount, pointer.glType, + pointer.normalized, this.strideSize, this.pointersOffset[bindingPointIndex]); + } + } + + } + + + + //===========// + // unbinding // + //===========// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void unbindBuffersFromAllBindingPoint() + { + for (int i = 0; i < this.pointers.length; i++) + { + GL32.glDisableVertexAttribArray(i); + } + } + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void unbindBuffersFromBindingPoint(int bindingPoint) + { + int[] bindingPointIndexes = this.bindingPointsToIndex[bindingPoint]; + for (int bindingPointIndex : bindingPointIndexes) + { + GL32.glDisableVertexAttribArray(bindingPointIndex); + } + } + + + + //==========================// + // manual attribute setting // + //==========================// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute) + { + TreeSet intArray = this.bindingPointsToIndexBuilder.computeIfAbsent(bindingPoint, k -> new TreeSet<>()); + intArray.add(attributeIndex); + + while (this.pointersBuilder.size() <= attributeIndex) + { + // This is dumb, but ArrayList doesn't have a resize, And this code + // should only be run when it's building the Vertex Attribute anyway. + this.pointersBuilder.add(null); + } + this.pointersBuilder.set(attributeIndex, attribute); + } + + + + //============// + // validation // + //============// + + /** Requires AbstractVertexAttribute to be bound */ + @Override + public void completeAndCheck(int expectedStrideSize) + { + int maxBindPointNumber = this.bindingPointsToIndexBuilder.lastKey(); + this.bindingPointsToIndex = new int[maxBindPointNumber + 1][]; + + this.bindingPointsToIndexBuilder.forEach((Integer i, TreeSet set) -> + { + this.bindingPointsToIndex[i] = new int[set.size()]; + Iterator iter = set.iterator(); + for (int j = 0; j < set.size(); j++) + { + this.bindingPointsToIndex[i][j] = iter.next(); + } + }); + + this.pointers = this.pointersBuilder.toArray(new VertexPointer[this.pointersBuilder.size()]); + this.pointersOffset = new int[this.pointers.length]; + this.pointersBuilder = null; // Release the builder + this.bindingPointsToIndexBuilder = null; // Release the builder + + // Check if all pointers are valid + int currentOffset = 0; + for (int i = 0; i < this.pointers.length; i++) + { + VertexPointer pointer = this.pointers[i]; + if (pointer == null) + { + LOGGER.warn("Vertex Attribute index " + i + " is not set! No index should be skipped normally!"); + continue; + } + this.pointersOffset[i] = currentOffset; + currentOffset += pointer.byteSize; + } + + if (currentOffset != expectedStrideSize) + { + LOGGER.error("Vertex Attribute calculated stride size " + currentOffset + + " does not match the provided expected stride size " + expectedStrideSize + "!"); + throw new IllegalArgumentException("Vertex Attribute Incorrect Format"); + } + this.strideSize = currentOffset; + LOGGER.info("Vertex Attribute (pre GL43) completed."); + + // Debug logging + LOGGER.debug("AttributeIndex: ElementCount, glType, normalized, strideSize, offset"); + + for (int i = 0; i < this.pointers.length; i++) + { + VertexPointer pointer = this.pointers[i]; + if (pointer == null) + { + LOGGER.debug(i + ": Null!!!!"); + } + else + { + LOGGER.debug(i + ": " + pointer.elementCount + ", " + + pointer.glType + ", " + pointer.normalized + ", " + this.strideSize + ", " + this.pointersOffset[i]); + } + } + + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java new file mode 100644 index 000000000..e05b2a621 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java @@ -0,0 +1,72 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; + +import com.seibel.distanthorizons.coreapi.util.MathUtil; +import org.lwjgl.opengl.GL32; + +public final class VertexPointer +{ + public final int elementCount; + public final int glType; + public final boolean normalized; + public final int byteSize; + public final boolean useInteger; + + + + // basic constructors // + + public VertexPointer(int elementCount, int glType, boolean normalized, int byteSize, boolean useInteger) + { + this.elementCount = elementCount; + this.glType = glType; + this.normalized = normalized; + this.byteSize = byteSize; + this.useInteger = useInteger; + } + public VertexPointer(int elementCount, int glType, boolean normalized, int byteSize) + { + this(elementCount, glType, normalized, byteSize, false); + } + private static int _align(int bytes) { return MathUtil.ceilDiv(bytes, 4) * 4; } + + + + // named constructors // + + public static VertexPointer addFloatPointer(boolean normalized) { return new VertexPointer(1, GL32.GL_FLOAT, normalized, Float.BYTES); } + public static VertexPointer addVec2Pointer(boolean normalized) { return new VertexPointer(2, GL32.GL_FLOAT, normalized, Float.BYTES * 2); } + public static VertexPointer addVec3Pointer(boolean normalized) { return new VertexPointer(3, GL32.GL_FLOAT, normalized, Float.BYTES * 3); } + public static VertexPointer addVec4Pointer(boolean normalized) { return new VertexPointer(4, GL32.GL_FLOAT, normalized, Float.BYTES * 4); } + /** Always aligned to 4 bytes */ + public static VertexPointer addUnsignedBytePointer(boolean normalized, boolean useInteger) { return new VertexPointer(1, GL32.GL_UNSIGNED_BYTE, normalized, 4, useInteger); } + /** aligned to 4 bytes */ + public static VertexPointer addUnsignedBytesPointer(int elementCount, boolean normalized, boolean useInteger) + { return new VertexPointer(elementCount, GL32.GL_UNSIGNED_BYTE, normalized, _align(elementCount), useInteger); } + public static VertexPointer addUnsignedShortsPointer(int elementCount, boolean normalized, boolean useInteger) + { return new VertexPointer(elementCount, GL32.GL_UNSIGNED_SHORT, normalized, _align(elementCount * 2), useInteger); } + public static VertexPointer addShortsPointer(int elementCount, boolean normalized, boolean useInteger) { return new VertexPointer(elementCount, GL32.GL_SHORT, normalized, _align(elementCount * 2), useInteger); } + public static VertexPointer addIntPointer(boolean normalized, boolean useInteger) { return new VertexPointer(1, GL32.GL_INT, normalized, 4, useInteger); } + public static VertexPointer addIVec2Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(2, GL32.GL_INT, normalized, 8, useInteger); } + public static VertexPointer addIVec3Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(3, GL32.GL_INT, normalized, 12, useInteger); } + public static VertexPointer addIVec4Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(4, GL32.GL_INT, normalized, 16, useInteger); } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java new file mode 100644 index 000000000..8405d39e7 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java @@ -0,0 +1,96 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import org.lwjgl.opengl.GL32; +import org.lwjgl.system.MemoryUtil; + +import java.nio.ByteBuffer; + +/** + * Renders a full-screen textured quad to the screen. + * Used in composite / deferred rendering (IE fog). + */ +public class ScreenQuad +{ + public static ScreenQuad INSTANCE = new ScreenQuad(); + + private static final float[] box_vertices = { + -1, -1, + 1, -1, + 1, 1, + -1, -1, + 1, 1, + -1, 1, + }; + + private AbstractVertexAttribute va; + private boolean init = false; + + + //=============// + // constructor // + //=============// + + private ScreenQuad() { } + + public void init() + { + if (this.init) return; + this.init = true; + + this.va = AbstractVertexAttribute.create(); + this.va.bind(); + + // Pos + this.va.setVertexAttribute(0, 0, VertexPointer.addVec2Pointer(false)); + this.va.completeAndCheck(Float.BYTES * 2); + + // Framebuffer + this.createBuffer(); + } + + public void render() + { + this.init(); + + //this.boxBuffer.bind(); + + this.va.bind(); + //this.va.bindBufferToAllBindingPoints(this.boxBuffer.getId()); + + GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 6); + } + + private void createBuffer() + { + ByteBuffer buffer = MemoryUtil.memAlloc(box_vertices.length * Float.BYTES); + buffer.asFloatBuffer().put(box_vertices); + buffer.rewind(); + + //this.boxBuffer = new GLVertexBuffer(false); + //this.boxBuffer.bind(); + //this.boxBuffer.uploadBuffer(buffer, box_vertices.length, EDhApiGpuUploadMethod.DATA, box_vertices.length * Float.BYTES); + MemoryUtil.memFree(buffer); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java new file mode 100644 index 000000000..70a777c2e --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java @@ -0,0 +1,188 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFadeShader; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.FadeApplyShader; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.VanillaFadeShader; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; +import com.seibel.distanthorizons.core.logging.DhLogger; +import org.lwjgl.opengl.GL32; + +import java.nio.ByteBuffer; + +/** + * Handles fading MC and DH together via {@link VanillaFadeShader} and {@link FadeApplyShader}.

+ * + * {@link VanillaFadeShader} - draws the Fade to a texture.
+ * {@link FadeApplyShader} - draws the Fade texture to MC's FrameBuffer.
+ */ +public class VanillaFadeRenderer +{ + public static VanillaFadeRenderer INSTANCE = new VanillaFadeRenderer(); + + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftClientWrapper MC_CLIENT = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private boolean init = false; + + private int width = -1; + private int height = -1; + private int fadeFramebuffer = -1; + + private int fadeTexture = -1; + + + + //=============// + // constructor // + //=============// + + private VanillaFadeRenderer() { } + + public void init() + { + if (this.init) return; + this.init = true; + + VanillaFadeShader.INSTANCE.init(); + FadeApplyShader.INSTANCE.init(); + } + + private void createFramebuffer(int width, int height) + { + if (this.fadeFramebuffer != -1) + { + GL32.glDeleteFramebuffers(this.fadeFramebuffer); + this.fadeFramebuffer = -1; + } + + this.fadeFramebuffer = GL32.glGenFramebuffers(); + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.fadeFramebuffer); + + + // Applying the fade texture is only needed if MC is drawing to their own frame buffer, + // otherwise we can directly render to their texture + if (MC_RENDER.mcRendersToFrameBuffer()) + { + if (this.fadeTexture != -1) + { + GLMC.glDeleteTextures(this.fadeTexture); + this.fadeTexture = -1; + } + + this.fadeTexture = GL32.glGenTextures(); + GLMC.glBindTexture(this.fadeTexture); + GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, GL32.GL_RGBA16, width, height, 0, GL32.GL_RGBA, GL32.GL_UNSIGNED_SHORT_4_4_4_4, (ByteBuffer) null); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MIN_FILTER, GL32.GL_LINEAR); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MAG_FILTER, GL32.GL_LINEAR); + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, this.fadeTexture, 0); + } + else + { + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, MC_RENDER.getColorTextureId(), 0); + } + } + + + + //========// + // render // + //========// + + public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) + { + int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); + if (depthTextureId == -1) + { + // the renderer hasn't been set up yet + // trying to render fading may cause GL errors + return; + } + + + + IProfilerWrapper profiler = MC_CLIENT.getProfiler(); + profiler.pop(); // get out of "terrain" + profiler.push("DH-Vanilla Fade"); + + + try(GLState mcState = new GLState()) + { + profiler.push("Vanilla Fade Generate"); + + this.init(); + + // resize the framebuffer if necessary + int width = MC_RENDER.getTargetFramebufferViewportWidth(); + int height = MC_RENDER.getTargetFramebufferViewportHeight(); + if (this.width != width || this.height != height) + { + this.width = width; + this.height = height; + this.createFramebuffer(width, height); + } + + + VanillaFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; + VanillaFadeShader.INSTANCE.setProjectionMatrix(mcModelViewMatrix, mcProjectionMatrix); + VanillaFadeShader.INSTANCE.setLevelMaxHeight(level.getMaxHeight()); + VanillaFadeShader.INSTANCE.render(0); + + // Applying the fade texture is only needed if MC is drawing to their own frame buffer, + // otherwise we can directly render to their texture + if (MC_RENDER.mcRendersToFrameBuffer()) + { + profiler.popPush("Vanilla Fade Apply"); + + FadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + FadeApplyShader.INSTANCE.readFramebuffer = DhFadeShader.INSTANCE.frameBuffer; + FadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); + FadeApplyShader.INSTANCE.render(0); + } + + profiler.pop(); + } + catch (Exception e) + { + LOGGER.error("Unexpected error during fade render, error: ["+e.getMessage()+"].", e); + } + } + + public void free() + { + VanillaFadeShader.INSTANCE.free(); + FadeApplyShader.INSTANCE.free(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java new file mode 100644 index 000000000..718e6a3c9 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java @@ -0,0 +1,199 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.logging.DhLogger; +import org.lwjgl.opengl.GL32; + +/** + * Copies {@link BlazeLodRenderer}'s currently active color and depth texture to Minecraft's framebuffer. + */ +public class DhApplyShader extends AbstractShaderRenderer +{ + public static DhApplyShader INSTANCE = new DhApplyShader(); + + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + // uniforms + public int gDhColorTextureUniform; + public int gDepthMapUniform; + + + + //=======// + // setup // + //=======// + //region + + private DhApplyShader() { } + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/apply.frag", + "vPosition" + ); + + // uniform setup + this.gDhColorTextureUniform = this.shader.getUniformLocation("gDhColorTexture"); + this.gDepthMapUniform = this.shader.getUniformLocation("gDhDepthTexture"); + + } + + @Override + protected void onApplyUniforms(float partialTicks) { } + + //endregion + + + + //========// + // render // + //========// + //region + + @Override + protected void onRender() + { + if (MC_RENDER.mcRendersToFrameBuffer()) + { + this.renderToFrameBuffer(); + } + else + { + this.renderToMcTexture(); + } + } + private void renderToFrameBuffer() + { + int targetFrameBuffer = MC_RENDER.getTargetFramebuffer(); + if (targetFrameBuffer == -1) + { + return; + } + + + try (GLState state = new GLState()) + { + + GLMC.disableDepthTest(); + + // blending isn't needed, we're manually merging the MC and DH textures + // Note: this prevents the sun/moon and stars from rendering through transparent LODs, + // however this also fixes transparent LODs from glowing when rendered against the sky during the day + GLMC.disableBlend(); + + // old blending logic in case it's ever needed: + //GLMC.enableBlend(); + //GL32.glBlendEquation(GL32.GL_FUNC_ADD); + //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveColorTextureId()); + GL32.glUniform1i(this.gDhColorTextureUniform, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GL32.glUniform1i(this.gDepthMapUniform, 1); + + // Copy to MC's framebuffer + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, targetFrameBuffer); + + ScreenQuad.INSTANCE.render(); + } + // everything's been restored, except at this point the MC framebuffer should now be used instead + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, targetFrameBuffer); + + } + private void renderToMcTexture() + { + int targetColorTextureId = MC_RENDER.getColorTextureId(); + if (targetColorTextureId == -1) + { + return; + } + + int dhFrameBufferId = BlazeLodRenderer.INSTANCE.getActiveFramebufferId(); + if (dhFrameBufferId == -1) + { + return; + } + + int mcFrameBufferId = MC_RENDER.getTargetFramebuffer(); + if (mcFrameBufferId == -1) + { + return; + } + + + + try (GLState state = new GLState()) + { + GLMC.disableDepthTest(); + + // blending isn't needed, we're just directly merging the MC and DH textures + // Note: this prevents the sun/moon and stars from rendering through transparent LODs, + // however this also fixes + GLMC.disableBlend(); + + // old blending logic in case it's ever needed: + //GLMC.enableBlend(); + //GL32.glBlendEquation(GL32.GL_FUNC_ADD); + //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveColorTextureId()); + GL32.glUniform1i(this.gDhColorTextureUniform, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GL32.glUniform1i(this.gDepthMapUniform, 1); + + + + GL32.glFramebufferTexture(GL32.GL_DRAW_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, targetColorTextureId, 0); + + // Copy to MC's texture via MC's framebuffer + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, dhFrameBufferId); + + ScreenQuad.INSTANCE.render(); + } + // everything's been restored, except at this point the MC framebuffer should now be used instead + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, mcFrameBufferId); + + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java new file mode 100644 index 000000000..222f26fe9 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java @@ -0,0 +1,161 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; + +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL43C; + +import java.nio.ByteBuffer; + +/** + * Handles fading MC and DH together via {@link DhFadeShader} and {@link FadeApplyShader}.

+ * + * {@link DhFadeShader} - draws the Fade to a texture.
+ * {@link FadeApplyShader} - draws the Fade texture to DH's framebuffer.
+ */ +public class DhFadeRenderer +{ + + public static DhFadeRenderer INSTANCE = new DhFadeRenderer(); + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private boolean init = false; + + private int width = -1; + private int height = -1; + private int fadeFramebuffer = -1; + + private int fadeTexture = -1; + + + + //=============// + // constructor // + //=============// + + private DhFadeRenderer() { } + + public void init() + { + if (this.init) return; + this.init = true; + + DhFadeShader.INSTANCE.init(); + FadeApplyShader.INSTANCE.init(); + } + + private void createFramebuffer(int width, int height) + { + if (this.fadeFramebuffer != -1) + { + GL32.glDeleteFramebuffers(this.fadeFramebuffer); + this.fadeFramebuffer = -1; + } + + this.fadeFramebuffer = GL32.glGenFramebuffers(); + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.fadeFramebuffer); + + + if (this.fadeTexture != -1) + { + GLMC.glDeleteTextures(this.fadeTexture); + this.fadeTexture = -1; + } + + this.fadeTexture = GL32.glGenTextures(); + { + GLMC.glBindTexture(this.fadeTexture); + GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, GL32.GL_RGBA16, width, height, 0, GL32.GL_RGBA, GL32.GL_UNSIGNED_SHORT_4_4_4_4, (ByteBuffer) null); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MIN_FILTER, GL32.GL_LINEAR); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MAG_FILTER, GL32.GL_LINEAR); + + // disable mip-mapping since DH is just going to draw straight to the screen + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_BASE_LEVEL, 0); + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_MAX_LEVEL, 0); + } + + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, this.fadeTexture, 0); + + } + + + + //========// + // render // + //========// + + public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, float partialTicks, IProfilerWrapper profiler) + { + try + { + profiler.push("Fade Generate"); + + this.init(); + + // resize the framebuffer if necessary + int width = MC_RENDER.getTargetFramebufferViewportWidth(); + int height = MC_RENDER.getTargetFramebufferViewportHeight(); + if (this.width != width || this.height != height) + { + this.width = width; + this.height = height; + this.createFramebuffer(width, height); + } + + + DhFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; + DhFadeShader.INSTANCE.setProjectionMatrix(mcModelViewMatrix, mcProjectionMatrix); + DhFadeShader.INSTANCE.render(partialTicks); + + // restored so we can write the fade texture to the main frame buffer + //mcState.restore(); + + profiler.popPush("Fade Apply"); + + FadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + FadeApplyShader.INSTANCE.readFramebuffer = DhFadeShader.INSTANCE.frameBuffer; + FadeApplyShader.INSTANCE.drawFramebuffer = BlazeLodRenderer.INSTANCE.getActiveFramebufferId(); + FadeApplyShader.INSTANCE.render(partialTicks); + } + catch (Exception e) + { + LOGGER.error("Unexpected error during fade render, error: ["+e.getMessage()+"].", e); + } + finally + { + profiler.pop(); + } + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java new file mode 100644 index 000000000..e8037a8d3 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java @@ -0,0 +1,165 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; + +public class DhFadeShader extends AbstractShaderRenderer +{ + public static DhFadeShader INSTANCE = new DhFadeShader(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int frameBuffer = -1; + + private Mat4f inverseDhMvmProjMatrix; + + + // Uniforms + + /** Inverted Model View Projection matrix */ + public int uDhInvMvmProj = -1; + + public int uDhDepthTexture = -1; + public int uMcColorTexture = -1; + public int uDhColorTexture = -1; + + public int uStartFadeBlockDistance = -1; + public int uEndFadeBlockDistance = -1; + + + + //=============// + // constructor // + //=============// + + public DhFadeShader() { } + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/fade/dhFade.frag", + "vPosition" + ); + + // all uniforms should be tryGet... + // because disabling fade can cause the GLSL to optimize out most (if not all) uniforms + + // near fade + this.uDhInvMvmProj = this.shader.tryGetUniformLocation("uDhInvMvmProj"); + + this.uDhDepthTexture = this.shader.tryGetUniformLocation("uDhDepthTexture"); + this.uMcColorTexture = this.shader.tryGetUniformLocation("uMcColorTexture"); + this.uDhColorTexture = this.shader.tryGetUniformLocation("uDhColorTexture"); + + this.uStartFadeBlockDistance = this.shader.tryGetUniformLocation("uStartFadeBlockDistance"); + this.uEndFadeBlockDistance = this.shader.tryGetUniformLocation("uEndFadeBlockDistance"); + + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + this.shader.setUniform(this.uDhInvMvmProj, this.inverseDhMvmProjMatrix); + + + float dhFarClipDistance = RenderUtil.getFarClipPlaneDistanceInBlocks(); + float fadeStartDistance = dhFarClipDistance * 0.5f; + float fadeEndDistance = dhFarClipDistance * 0.9f; + + this.shader.setUniform(this.uStartFadeBlockDistance, fadeStartDistance); + this.shader.setUniform(this.uEndFadeBlockDistance, fadeEndDistance); + + } + + public void setProjectionMatrix(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + { + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + + Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); + inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); + inverseDhModelViewProjectionMatrix.invert(); + this.inverseDhMvmProjMatrix = inverseDhModelViewProjectionMatrix; + } + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = BlazeLodRenderer.INSTANCE.getActiveColorTextureId(); + + if (depthTextureId == -1 + || colorTextureId == -1) + { + // the renderer is currently being re-built and/or inactive, + // we don't need to/can't render fading + return; + } + + + + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.frameBuffer); + GLMC.disableScissorTest(); + GLMC.disableDepthTest(); + GLMC.disableBlend(); + + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(depthTextureId); + GL32.glUniform1i(this.uDhDepthTexture, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(MC_RENDER.getColorTextureId()); + GL32.glUniform1i(this.uMcColorTexture, 1); + + GLMC.glActiveTexture(GL32.GL_TEXTURE2); + GLMC.glBindTexture(colorTextureId); + GL32.glUniform1i(this.uDhColorTexture, 2); + + + ScreenQuad.INSTANCE.render(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java new file mode 100644 index 000000000..366755515 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java @@ -0,0 +1,118 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.VanillaFadeRenderer; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; + +/** + * Draws the Fade texture onto Minecraft's FrameBuffer.

+ * + * See Also:
+ * {@link VanillaFadeRenderer} - Parent to this shader.
+ * {@link VanillaFadeShader} - draws the Fade texture.
+ */ +public class FadeApplyShader extends AbstractShaderRenderer +{ + public static FadeApplyShader INSTANCE = new FadeApplyShader(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + + public int fadeTexture; + + public int readFramebuffer; + public int drawFramebuffer; + + // uniforms + public int uFadeColorTextureUniform = -1; + + + + //=============// + // constructor // + //=============// + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/fade/apply.frag", + "vPosition" + ); + + // uniform setup + this.uFadeColorTextureUniform = this.shader.getUniformLocation("uFadeColorTextureUniform"); + + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(this.fadeTexture); + GL32.glUniform1i(this.uFadeColorTextureUniform, 0); + + } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + GLMC.disableBlend(); + + // Depth testing must be disabled otherwise this application shader won't apply anything. + // setting this isn't necessary in vanilla, but some mods may change this, requiring it to be set manually, + // it should be automatically restored after rendering is complete. + GLMC.disableDepthTest(); + + + // apply the rendered Fade to Minecraft's framebuffer + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, this.readFramebuffer); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, this.drawFramebuffer); + + ScreenQuad.INSTANCE.render(); + + GLMC.enableDepthTest(); + + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java new file mode 100644 index 000000000..48f625d57 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java @@ -0,0 +1,198 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.util.RenderUtil; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; + +public class VanillaFadeShader extends AbstractShaderRenderer +{ + public static VanillaFadeShader INSTANCE = new VanillaFadeShader(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int frameBuffer = -1; + + private Mat4f inverseMcMvmProjMatrix; + private Mat4f inverseDhMvmProjMatrix; + private float levelMaxHeight; + + + // Uniforms + public int uMcDepthTexture = -1; + public int uDhDepthTexture = -1; + public int uCombinedMcDhColorTexture = -1; + public int uDhColorTexture = -1; + + /** Inverted Model View Projection matrix */ + public int uDhInvMvmProj = -1; + public int uMcInvMvmProj = -1; + + public int uStartFadeBlockDistance = -1; + public int uEndFadeBlockDistance = -1; + public int uMaxLevelHeight = -1; + + public int uOnlyRenderLods = -1; + + + + //=============// + // constructor // + //=============// + + public VanillaFadeShader() { } + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/fade/vanillaFade.frag", + "vPosition" + ); + + // all uniforms should be tryGet... + // because disabling fade can cause the GLSL to optimize out most (if not all) uniforms + + // near fade + this.uDhInvMvmProj = this.shader.tryGetUniformLocation("uDhInvMvmProj"); + this.uMcInvMvmProj = this.shader.tryGetUniformLocation("uMcInvMvmProj"); + + this.uMcDepthTexture = this.shader.tryGetUniformLocation("uMcDepthTexture"); + this.uDhDepthTexture = this.shader.tryGetUniformLocation("uDhDepthTexture"); + this.uCombinedMcDhColorTexture = this.shader.tryGetUniformLocation("uCombinedMcDhColorTexture"); + this.uDhColorTexture = this.shader.tryGetUniformLocation("uDhColorTexture"); + + this.uStartFadeBlockDistance = this.shader.tryGetUniformLocation("uStartFadeBlockDistance"); + this.uEndFadeBlockDistance = this.shader.tryGetUniformLocation("uEndFadeBlockDistance"); + this.uMaxLevelHeight = this.shader.tryGetUniformLocation("uMaxLevelHeight"); + + this.uOnlyRenderLods = this.shader.tryGetUniformLocation("uOnlyRenderLods"); + + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + this.shader.setUniform(this.uMcInvMvmProj, this.inverseMcMvmProjMatrix); + this.shader.setUniform(this.uDhInvMvmProj, this.inverseDhMvmProjMatrix); + + + float dhNearClipDistance = RenderUtil.getNearClipPlaneInBlocks(); + // this added value prevents the near clip plane and discard circle from touching, which looks bad + dhNearClipDistance += 16f; + + // measured in blocks + // these multipliers in James' tests should provide a fairly smooth transition + // without having underdraw issues + float fadeStartDistance = dhNearClipDistance * 1.5f; + float fadeEndDistance = dhNearClipDistance * 1.9f; + + this.shader.setUniform(this.uStartFadeBlockDistance, fadeStartDistance); + this.shader.setUniform(this.uEndFadeBlockDistance, fadeEndDistance); + + this.shader.setUniform(this.uMaxLevelHeight, this.levelMaxHeight); + + this.shader.setUniform(this.uOnlyRenderLods, Config.Client.Advanced.Debugging.lodOnlyMode.get()); + } + + public void setProjectionMatrix(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + { + Mat4f inverseMcModelViewProjectionMatrix = new Mat4f(mcProjectionMatrix); + inverseMcModelViewProjectionMatrix.multiply(mcModelViewMatrix); + inverseMcModelViewProjectionMatrix.invert(); + this.inverseMcMvmProjMatrix = inverseMcModelViewProjectionMatrix; + + + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + + Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); + inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); + inverseDhModelViewProjectionMatrix.invert(); + this.inverseDhMvmProjMatrix = inverseDhModelViewProjectionMatrix; + } + public void setLevelMaxHeight(int levelMaxHeight) { this.levelMaxHeight = levelMaxHeight; } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = BlazeLodRenderer.INSTANCE.getActiveColorTextureId(); + + if (depthTextureId == -1 + || colorTextureId == -1) + { + // the renderer is currently being re-built and/or inactive, + // we don't need to/can't render fading + return; + } + + + + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.frameBuffer); + GLMC.disableScissorTest(); + GLMC.disableDepthTest(); + GLMC.disableBlend(); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(MC_RENDER.getDepthTextureId()); + GL32.glUniform1i(this.uMcDepthTexture, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(depthTextureId); + GL32.glUniform1i(this.uDhDepthTexture, 1); + + GLMC.glActiveTexture(GL32.GL_TEXTURE2); + GLMC.glBindTexture(MC_RENDER.getColorTextureId()); + GL32.glUniform1i(this.uCombinedMcDhColorTexture, 2); + + GLMC.glActiveTexture(GL32.GL_TEXTURE3); + GLMC.glBindTexture(colorTextureId); + GL32.glUniform1i(this.uDhColorTexture, 3); + + + ScreenQuad.INSTANCE.render(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java new file mode 100644 index 000000000..58fca26d3 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java @@ -0,0 +1,118 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import org.lwjgl.opengl.GL32; + +/** + * Draws the Fog texture onto DH's FrameBuffer.

+ * + * See Also:
+ * {@link FogRenderer} - Parent to this shader.
+ * {@link FogShader} - draws the Fog texture.
+ */ +public class FogApplyShader extends AbstractShaderRenderer +{ + public static FogApplyShader INSTANCE = new FogApplyShader(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int fogTexture; + + // uniforms + public int colorTextureUniform; + public int depthTextureUniform; + + + + //=============// + // constructor // + //=============// + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/fog/apply.frag", + "vPosition" + ); + + // uniform setup + this.colorTextureUniform = this.shader.getUniformLocation("uColorTexture"); + this.depthTextureUniform = this.shader.getUniformLocation("uDepthTexture"); + + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(this.fogTexture); + GL32.glUniform1i(this.colorTextureUniform, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GL32.glUniform1i(this.depthTextureUniform, 1); + + } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + GLMC.enableBlend(); + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + + // Depth testing must be disabled otherwise this application shader won't apply anything. + // setting this isn't necessary in vanilla, but some mods may change this, requiring it to be set manually, + // it should be automatically restored after rendering is complete. + GLMC.disableDepthTest(); + + + // apply the rendered Fog to DH's framebuffer + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, FogShader.INSTANCE.frameBuffer); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, BlazeLodRenderer.INSTANCE.getActiveFramebufferId()); + + ScreenQuad.INSTANCE.render(); + + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, 0); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java new file mode 100644 index 000000000..04079baf7 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java @@ -0,0 +1,140 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL43C; + +import java.nio.ByteBuffer; + +/** + * Handles adding SSAO via {@link FogShader} and {@link FogApplyShader}.

+ * + * {@link FogShader} - draws the Fog to a texture.
+ * {@link FogApplyShader} - draws the Fog texture to DH's FrameBuffer.
+ */ +public class FogRenderer +{ + public static FogRenderer INSTANCE = new FogRenderer(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private boolean init = false; + + private int width = -1; + private int height = -1; + private int fogFramebuffer = -1; + + private int fogTexture = -1; + + + + //=============// + // constructor // + //=============// + + private FogRenderer() { } + + public void init() + { + if (this.init) return; + this.init = true; + + FogShader.INSTANCE.init(); + FogApplyShader.INSTANCE.init(); + } + + private void createFramebuffer(int width, int height) + { + if (this.fogFramebuffer != -1) + { + GL32.glDeleteFramebuffers(this.fogFramebuffer); + this.fogFramebuffer = -1; + } + + if (this.fogTexture != -1) + { + GLMC.glDeleteTextures(this.fogTexture); + this.fogTexture = -1; + } + + this.fogFramebuffer = GL32.glGenFramebuffers(); + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.fogFramebuffer); + + this.fogTexture = GLMC.glGenTextures(); + { + GLMC.glBindTexture(this.fogTexture); + GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, GL32.GL_RGBA16, width, height, 0, GL32.GL_RGBA, GL32.GL_UNSIGNED_SHORT_4_4_4_4, (ByteBuffer) null); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MIN_FILTER, GL32.GL_LINEAR); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MAG_FILTER, GL32.GL_LINEAR); + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, this.fogTexture, 0); + + // disable mip-mapping since DH is just going to draw straight to the screen + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_BASE_LEVEL, 0); + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_MAX_LEVEL, 0); + } + } + + + + //========// + // render // + //========// + + public void render(Mat4f modelViewProjectionMatrix, float partialTicks) + { + // GLState needed in MC 1.16.5 probably due to MC not manually setting each GL state they need before the next rendering step + try (GLState state = new GLState()) + { + this.init(); + + // resize the framebuffer if necessary + int width = MC_RENDER.getTargetFramebufferViewportWidth(); + int height = MC_RENDER.getTargetFramebufferViewportHeight(); + if (this.width != width || this.height != height) + { + this.width = width; + this.height = height; + this.createFramebuffer(width, height); + } + + FogShader.INSTANCE.frameBuffer = this.fogFramebuffer; + FogShader.INSTANCE.setProjectionMatrix(modelViewProjectionMatrix); + FogShader.INSTANCE.render(partialTicks); + + FogApplyShader.INSTANCE.fogTexture = this.fogTexture; + FogApplyShader.INSTANCE.render(partialTicks); + } + } + + public void free() + { + FogShader.INSTANCE.free(); + FogApplyShader.INSTANCE.free(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java new file mode 100644 index 000000000..714eab500 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java @@ -0,0 +1,72 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; + +import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogFalloff; + +import java.util.Objects; + +/** + * Contains all configurable options related to fog. + * + * @version 2022-4-13 + */ +public class FogSettings +{ + /** a FogSetting object with 0 for every value */ + public static final FogSettings EMPTY = new FogSettings(0, 0, 0, 0, 0, EDhApiFogFalloff.LINEAR); + + + public final double start; + public final double end; + public final double min; + public final double max; + public final double density; + public final EDhApiFogFalloff fogType; + + public FogSettings(double start, double end, double min, double max, double density, EDhApiFogFalloff fogType) + { + this.start = start; + this.end = end; + this.min = min; + this.max = max; + this.density = density; + this.fogType = fogType; + } + + @Override + public boolean equals(Object o) + { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + FogSettings that = (FogSettings) o; + return Double.compare(that.start, start) == 0 && Double.compare(that.end, end) == 0 && Double.compare(that.min, min) == 0 && Double.compare(that.max, max) == 0 && Double.compare(that.density, density) == 0 && fogType == that.fogType; + } + + @Override + public int hashCode() + { + return Objects.hash(start, end, min, max, density, fogType); + } + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java new file mode 100644 index 000000000..0ac0b00ab --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java @@ -0,0 +1,287 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; + +import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; + +import java.awt.*; + +public class FogShader extends AbstractShaderRenderer +{ + public static final FogShader INSTANCE = new FogShader(); + + private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + + + public int frameBuffer; + + private Mat4f inverseMvmProjMatrix; + + + + //==========// + // Uniforms // + //==========// + + public int uDepthMap; + /** Inverted Model View Projection matrix */ + public int uInvMvmProj; + + // fog uniforms + public int uFogColor; + public int uFogScale; + public int uFogVerticalScale; + public int uFogDebugMode; + public int uFogFalloffType; + + // far fog + public int uFarFogStart; + public int uFarFogLength; + public int uFarFogMin; + public int uFarFogRange; + public int uFarFogDensity; + + // height fog + public int uHeightFogStart; + public int uHeightFogLength; + public int uHeightFogMin; + public int uHeightFogRange; + public int uHeightFogDensity; + + public int uHeightFogEnabled; + public int uHeightFogFalloffType; + public int uHeightBasedOnCamera; + public int uHeightFogBaseHeight; + public int uHeightFogAppliesUp; + public int uHeightFogAppliesDown; + public int uUseSphericalFog; + public int uHeightFogMixingMode; + public int uCameraBlockYPos; + + + + //=============// + // constructor // + //=============// + + public FogShader() { } + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/fog/fog.frag", + "vPosition" + ); + + // all uniforms should be tryGet... + // because disabling fog can cause the GLSL to optimize out most (if not all) uniforms + + this.uDepthMap = this.shader.getUniformLocation("uDepthMap"); + this.uInvMvmProj = this.shader.getUniformLocation("uInvMvmProj"); + + // Fog uniforms + this.uFogScale = this.shader.getUniformLocation("uFogScale"); + this.uFogVerticalScale = this.shader.getUniformLocation("uFogVerticalScale"); + this.uFogColor = this.shader.getUniformLocation("uFogColor"); + this.uFogDebugMode = this.shader.getUniformLocation("uFogDebugMode"); + this.uFogFalloffType = this.shader.getUniformLocation("uFogFalloffType"); + + // fog config + this.uFarFogStart = this.shader.getUniformLocation("uFarFogStart"); + this.uFarFogLength = this.shader.getUniformLocation("uFarFogLength"); + this.uFarFogMin = this.shader.getUniformLocation("uFarFogMin"); + this.uFarFogRange = this.shader.getUniformLocation("uFarFogRange"); + this.uFarFogDensity = this.shader.getUniformLocation("uFarFogDensity"); + + // height fog + this.uHeightFogStart = this.shader.getUniformLocation("uHeightFogStart"); + this.uHeightFogLength = this.shader.getUniformLocation("uHeightFogLength"); + this.uHeightFogMin = this.shader.getUniformLocation("uHeightFogMin"); + this.uHeightFogRange = this.shader.getUniformLocation("uHeightFogRange"); + this.uHeightFogDensity = this.shader.getUniformLocation("uHeightFogDensity"); + + this.uHeightFogEnabled = this.shader.getUniformLocation("uHeightFogEnabled"); + this.uHeightFogFalloffType = this.shader.getUniformLocation("uHeightFogFalloffType"); + this.uHeightBasedOnCamera = this.shader.getUniformLocation("uHeightBasedOnCamera"); + this.uHeightFogBaseHeight = this.shader.getUniformLocation("uHeightFogBaseHeight"); + this.uHeightFogAppliesUp = this.shader.getUniformLocation("uHeightFogAppliesUp"); + this.uHeightFogAppliesDown = this.shader.getUniformLocation("uHeightFogAppliesDown"); + this.uUseSphericalFog = this.shader.getUniformLocation("uUseSphericalFog"); + this.uHeightFogMixingMode = this.shader.getUniformLocation("uHeightFogMixingMode"); + this.uCameraBlockYPos = this.shader.getUniformLocation("uCameraBlockYPos"); + + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + int lodDrawDistance = Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius.get() * LodUtil.CHUNK_WIDTH; + + + + if (this.inverseMvmProjMatrix != null) + { + this.shader.setUniform(this.uInvMvmProj, this.inverseMvmProjMatrix); + } + + + // Fog uniforms + this.shader.setUniform(this.uFogColor, this.getFogColor(partialTicks)); + this.shader.setUniform(this.uFogScale, 1.f / lodDrawDistance); + this.shader.setUniform(this.uFogVerticalScale, 1.f / MC.getWrappedClientLevel().getMaxHeight()); + // only used for debugging + this.shader.setUniform(this.uFogDebugMode, 0); // 1 = render everything with fog color // 7 = use debug rendering + this.shader.setUniform(this.uFogFalloffType, Config.Client.Advanced.Graphics.Fog.farFogFalloff.get().value); + + + // fog config + float farFogStart = Config.Client.Advanced.Graphics.Fog.farFogStart.get(); + float farFogEnd = Config.Client.Advanced.Graphics.Fog.farFogEnd.get(); + float farFogMin = Config.Client.Advanced.Graphics.Fog.farFogMin.get(); + float farFogMax = Config.Client.Advanced.Graphics.Fog.farFogMax.get(); + float farFogDensity = Config.Client.Advanced.Graphics.Fog.farFogDensity.get(); + + // override fog if underwater + if (MC_RENDER.isFogStateSpecial()) + { + // hide everything behind fog + farFogStart = 0.0f; + farFogEnd = 0.0f; + } + + this.shader.setUniform(this.uFarFogStart, farFogStart); + this.shader.setUniform(this.uFarFogLength, farFogEnd - farFogStart); + this.shader.setUniform(this.uFarFogMin, farFogMin); + this.shader.setUniform(this.uFarFogRange, farFogMax - farFogMin); + this.shader.setUniform(this.uFarFogDensity, farFogDensity); + + + // height config + EDhApiHeightFogMixMode heightFogMixingMode = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMixMode.get(); + boolean heightFogEnabled = heightFogMixingMode != EDhApiHeightFogMixMode.SPHERICAL && heightFogMixingMode != EDhApiHeightFogMixMode.CYLINDRICAL; + boolean useSphericalFog = heightFogMixingMode == EDhApiHeightFogMixMode.SPHERICAL; + EDhApiHeightFogDirection heightFogCameraDirection = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogDirection.get(); + + float heightFogStart = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogStart.get(); + float heightFogEnd = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogEnd.get(); + float heightFogMin = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMin.get(); + float heightFogMax = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogMax.get(); + float heightFogDensity = Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogDensity.get(); + + this.shader.setUniform(this.uHeightFogStart, heightFogStart); + this.shader.setUniform(this.uHeightFogLength, heightFogEnd - heightFogStart); + this.shader.setUniform(this.uHeightFogMin, heightFogMin); + this.shader.setUniform(this.uHeightFogRange, heightFogMax - heightFogMin); + this.shader.setUniform(this.uHeightFogDensity, heightFogDensity); + + + this.shader.setUniform(this.uHeightFogEnabled, heightFogEnabled); + this.shader.setUniform(this.uHeightFogFalloffType, Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogFalloff.get().value); + this.shader.setUniform(this.uHeightFogBaseHeight, Config.Client.Advanced.Graphics.Fog.HeightFog.heightFogBaseHeight.get()); + this.shader.setUniform(this.uHeightBasedOnCamera, heightFogCameraDirection.basedOnCamera); + this.shader.setUniform(this.uHeightFogAppliesUp, heightFogCameraDirection.fogAppliesUp); + this.shader.setUniform(this.uHeightFogAppliesDown, heightFogCameraDirection.fogAppliesDown); + this.shader.setUniform(this.uUseSphericalFog, useSphericalFog); + this.shader.setUniform(this.uHeightFogMixingMode, heightFogMixingMode.value); + this.shader.setUniform(this.uCameraBlockYPos, (float)MC_RENDER.getCameraExactPosition().y); + + } + private Color getFogColor(float partialTicks) + { + Color fogColor; + + if (Config.Client.Advanced.Graphics.Fog.colorMode.get() == EDhApiFogColorMode.USE_SKY_COLOR) + { + fogColor = MC_RENDER.getSkyColor(); + } + else + { + fogColor = MC_RENDER.getFogColor(partialTicks); + } + + return fogColor; + } + + public void setProjectionMatrix(Mat4f modelViewProjectionMatrix) + { + this.inverseMvmProjMatrix = new Mat4f(modelViewProjectionMatrix); + this.inverseMvmProjMatrix.invert(); + } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.frameBuffer); + GLMC.disableScissorTest(); + GLMC.disableDepthTest(); + GLMC.disableBlend(); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GL32.glUniform1i(this.uDepthMap, 0); + + // this is necessary for MC 1.16 (IE Legacy OpenGL) + // otherwise the framebuffer isn't cleared correctly and the fog smears across the screen + if (MC_RENDER.runningLegacyOpenGL()) + { + // in another part of the DH code we set the fog color to opaque, here it needs to be transparent + float[] clearColorValues = new float[4]; + GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); + GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 0.0f); + + GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + } + + + ScreenQuad.INSTANCE.render(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java new file mode 100644 index 000000000..0da10356a --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java @@ -0,0 +1,145 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.util.RenderUtil; +import org.lwjgl.opengl.GL32; + +/** + * Draws the SSAO texture onto DH's FrameBuffer.

+ * + * See Also:
+ * {@link SSAORenderer} - Parent to this shader.
+ * {@link SSAOShader} - draws the SSAO texture.
+ */ +public class SSAOApplyShader extends AbstractShaderRenderer +{ + public static SSAOApplyShader INSTANCE = new SSAOApplyShader(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int ssaoTexture; + + // uniforms + public int gSSAOMapUniform; + public int gDepthMapUniform; + public int gViewSizeUniform; + public int gBlurRadiusUniform; + public int gNearUniform; + public int gFarUniform; + + + + //=============// + // constructor // + //=============// + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/ssao/apply.frag", + "vPosition" + ); + + // uniform setup + this.gSSAOMapUniform = this.shader.getUniformLocation("gSSAOMap"); + this.gDepthMapUniform = this.shader.getUniformLocation("gDepthMap"); + this.gViewSizeUniform = this.shader.tryGetUniformLocation("gViewSize"); + this.gBlurRadiusUniform = this.shader.tryGetUniformLocation("gBlurRadius"); + this.gNearUniform = this.shader.tryGetUniformLocation("gNear"); + this.gFarUniform = this.shader.tryGetUniformLocation("gFar"); + } + + + + //=============// + // render prep // + //=============// + + @Override + protected void onApplyUniforms(float partialTicks) + { + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GL32.glUniform1i(this.gDepthMapUniform, 0); + + GLMC.glActiveTexture(GL32.GL_TEXTURE1); + GLMC.glBindTexture(this.ssaoTexture); + GL32.glUniform1i(this.gSSAOMapUniform, 1); + + GL32.glUniform1i(this.gBlurRadiusUniform, 2); + + if (this.gViewSizeUniform >= 0) + { + GL32.glUniform2f(this.gViewSizeUniform, + MC_RENDER.getTargetFramebufferViewportWidth(), + MC_RENDER.getTargetFramebufferViewportHeight()); + } + + if (this.gNearUniform >= 0) + { + GL32.glUniform1f(this.gNearUniform, + RenderUtil.getNearClipPlaneInBlocks()); + } + + if (this.gFarUniform >= 0) + { + float farClipPlane = RenderUtil.getFarClipPlaneDistanceInBlocks(); + GL32.glUniform1f(this.gFarUniform, farClipPlane); + } + } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + GLMC.enableBlend(); + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_ZERO, GL32.GL_SRC_ALPHA, GL32.GL_ZERO, GL32.GL_ONE); + + // Depth testing must be disabled otherwise this application shader won't apply anything. + // setting this isn't necessary in vanilla, but some mods may change this, requiring it to be set manually, + // it should be automatically restored after rendering is complete. + GLMC.disableDepthTest(); + + // apply the rendered SSAO to the LODs + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, SSAOShader.INSTANCE.frameBuffer); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, BlazeLodRenderer.INSTANCE.getActiveFramebufferId()); + + + ScreenQuad.INSTANCE.render(); + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java new file mode 100644 index 000000000..88d3172c7 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java @@ -0,0 +1,140 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import org.lwjgl.opengl.GL32; +import org.lwjgl.opengl.GL43C; + +import java.nio.ByteBuffer; + +/** + * Handles adding SSAO via {@link SSAOShader} and {@link SSAOApplyShader}.

+ * + * {@link SSAOShader} - draws the SSAO to a texture.
+ * {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
+ */ +public class SSAORenderer +{ + public static SSAORenderer INSTANCE = new SSAORenderer(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private boolean init = false; + + private int width = -1; + private int height = -1; + private int ssaoFramebuffer = -1; + + private int ssaoTexture = -1; + + + + //=============// + // constructor // + //=============// + + private SSAORenderer() { } + + public void init() + { + if (this.init) return; + this.init = true; + + SSAOShader.INSTANCE.init(); + SSAOApplyShader.INSTANCE.init(); + } + + private void createFramebuffer(int width, int height) + { + if (this.ssaoFramebuffer != -1) + { + GL32.glDeleteFramebuffers(this.ssaoFramebuffer); + this.ssaoFramebuffer = -1; + } + + if (this.ssaoTexture != -1) + { + GLMC.glDeleteTextures(this.ssaoTexture); + this.ssaoTexture = -1; + } + + this.ssaoFramebuffer = GL32.glGenFramebuffers(); + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.ssaoFramebuffer); + + this.ssaoTexture = GLMC.glGenTextures(); + { + GLMC.glBindTexture(this.ssaoTexture); + GL32.glTexImage2D(GL32.GL_TEXTURE_2D, 0, GL32.GL_R16F, width, height, 0, GL32.GL_RED, GL32.GL_HALF_FLOAT, (ByteBuffer) null); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MIN_FILTER, GL32.GL_LINEAR); + GL32.glTexParameteri(GL32.GL_TEXTURE_2D, GL32.GL_TEXTURE_MAG_FILTER, GL32.GL_LINEAR); + + // disable mip-mapping since DH is just going to draw straight to the screen + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_BASE_LEVEL, 0); + GL43C.glTexParameteri(GL43C.GL_TEXTURE_2D, GL43C.GL_TEXTURE_MAX_LEVEL, 0); + } + + GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_TEXTURE_2D, this.ssaoTexture, 0); + } + + + + //========// + // render // + //========// + + public void render(Mat4f projectionMatrix, float partialTicks) + { + try(GLState state = new GLState()) + { + this.init(); + + // resize the framebuffer if necessary + int width = MC_RENDER.getTargetFramebufferViewportWidth(); + int height = MC_RENDER.getTargetFramebufferViewportHeight(); + if (this.width != width || this.height != height) + { + this.width = width; + this.height = height; + this.createFramebuffer(width, height); + } + + SSAOShader.INSTANCE.frameBuffer = this.ssaoFramebuffer; + SSAOShader.INSTANCE.setProjectionMatrix(projectionMatrix); + SSAOShader.INSTANCE.render(partialTicks); + + SSAOApplyShader.INSTANCE.ssaoTexture = this.ssaoTexture; + SSAOApplyShader.INSTANCE.render(partialTicks); + } + } + + public void free() + { + SSAOShader.INSTANCE.free(); + SSAOApplyShader.INSTANCE.free(); + } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java new file mode 100644 index 000000000..36e285d24 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java @@ -0,0 +1,142 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.util.math.Mat4f; +import org.lwjgl.opengl.GL32; + +/** + * Draws the SSAO to a texture.

+ * + * See Also:
+ * {@link SSAORenderer} - Parent to this shader.
+ * {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
+ */ +public class SSAOShader extends AbstractShaderRenderer +{ + public static SSAOShader INSTANCE = new SSAOShader(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + public int frameBuffer; + + private Mat4f projection; + private Mat4f invertedProjection; + + + // uniforms + public int uProj; + public int uInvProj; + public int uSampleCount; + public int uRadius; + public int uStrength; + public int uMinLight; + public int uBias; + public int uDepthMap; + public int uFadeDistanceInBlocks; + + + + //=============// + // constructor // + //=============// + + @Override + public void onInit() + { + this.shader = new ShaderProgram( + "shaders/quadApply.vert", + "shaders/ssao/ao.frag", + "vPosition" + ); + + // uniform setup + this.uProj = this.shader.getUniformLocation("uProj"); + this.uInvProj = this.shader.getUniformLocation("uInvProj"); + this.uSampleCount = this.shader.getUniformLocation("uSampleCount"); + this.uRadius = this.shader.getUniformLocation("uRadius"); + this.uStrength = this.shader.getUniformLocation("uStrength"); + this.uMinLight = this.shader.getUniformLocation("uMinLight"); + this.uBias = this.shader.getUniformLocation("uBias"); + this.uDepthMap = this.shader.getUniformLocation("uDepthMap"); + this.uFadeDistanceInBlocks = this.shader.getUniformLocation("uFadeDistanceInBlocks"); + } + + + + //=============// + // render prep // + //=============// + + public void setProjectionMatrix(Mat4f projectionMatrix) + { + this.projection = projectionMatrix; + + this.invertedProjection = new Mat4f(projectionMatrix); + this.invertedProjection.invert(); + } + + @Override + protected void onApplyUniforms(float partialTicks) + { + this.shader.setUniform(this.uProj, this.projection); + + this.shader.setUniform(this.uInvProj, this.invertedProjection); + + this.shader.setUniform(this.uSampleCount, 6); + this.shader.setUniform(this.uRadius, 4.0f); + this.shader.setUniform(this.uStrength, 0.2f); + this.shader.setUniform(this.uMinLight, 0.25f); + this.shader.setUniform(this.uBias, 0.02f); + this.shader.setUniform(this.uFadeDistanceInBlocks, 1_600.0f); + + GL32.glUniform1i(this.uDepthMap, 0); + + } + + + + //========// + // render // + //========// + + @Override + protected void onRender() + { + GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.frameBuffer); + GLMC.disableScissorTest(); + GLMC.disableDepthTest(); + GLMC.disableBlend(); + + GLMC.glActiveTexture(GL32.GL_TEXTURE0); + GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + + ScreenQuad.INSTANCE.render(); + } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java new file mode 100644 index 000000000..8daab7b83 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java @@ -0,0 +1,141 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.test; + +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; + +import org.lwjgl.opengl.GL32; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +/** + * Renders a UV colored quad + * to the center of the screen to confirm DH's + * apply shader is running correctly + */ +public class GlTestRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + public static final GlTestRenderer INSTANCE = new GlTestRenderer(); + + // Render a square with uv color + private static final float[] VERTICES = + { + // PosX,Y, ColorR,G,B,A + -0.5f, -0.5f, 1.0f, 0.0f, 0.0f, 1.0f, + 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, + 0.0f, 0.5f, 0.0f, 0.0f, 1.0f, 1.0f, + }; + + + + ShaderProgram basicShader; + GLVertexBuffer vbo; + AbstractVertexAttribute va; + boolean init = false; + + + + //=============// + // constructor // + //=============// + //region + + private GlTestRenderer() { } + + public void init() + { + if (this.init) + { + return; + } + + LOGGER.info("init"); + this.init = true; + this.va = AbstractVertexAttribute.create(); + this.va.bind(); + // Pos + this.va.setVertexAttribute(0, 0, VertexPointer.addVec2Pointer(false)); + // Color + this.va.setVertexAttribute(0, 1, VertexPointer.addVec4Pointer(false)); + this.va.completeAndCheck(Float.BYTES * 6); + this.basicShader = new ShaderProgram( + "shaders/test/vert.vert", + "shaders/test/frag.frag", + new String[]{"vPosition", "color"}); + + this.createBuffer(); + } + + private void createBuffer() + { + ByteBuffer buffer = ByteBuffer.allocateDirect(VERTICES.length * Float.BYTES); + // Fill buffer with vertices. + buffer.order(ByteOrder.nativeOrder()); + buffer.asFloatBuffer().put(VERTICES); + buffer.rewind(); + + this.vbo = new GLVertexBuffer(false); + this.vbo.bind(); + this.vbo.uploadBuffer(buffer, 4, EDhApiGpuUploadMethod.DATA, VERTICES.length * Float.BYTES); + } + + //endregion + + + + //========// + // render // + //========// + //region + + public void render() + { + this.init(); + + this.basicShader.bind(); + this.va.bind(); + + this.vbo.bind(); + this.va.bindBufferToAllBindingPoints(this.vbo.getId()); + + // Render the square + GL32.glDrawArrays(GL32.GL_TRIANGLE_FAN, 0, 4); + } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java new file mode 100644 index 000000000..92e4a1e68 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java @@ -0,0 +1,77 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.util; + +import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import org.lwjgl.opengl.GL32; + +public abstract class AbstractShaderRenderer +{ + protected static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + + + protected ShaderProgram shader; + + protected boolean init = false; + + + protected AbstractShaderRenderer() {} + + public void init() + { + if (this.init) return; + this.init = true; + + this.onInit(); + } + + public void render(float partialTicks) + { + this.init(); + + this.shader.bind(); + + this.onApplyUniforms(partialTicks); + + int width = MC_RENDER.getTargetFramebufferViewportWidth(); + int height = MC_RENDER.getTargetFramebufferViewportHeight(); + GL32.glViewport(0, 0, width, height); + + this.onRender(); + + this.shader.unbind(); + } + + public void free() + { + if (this.shader != null) + { + this.shader.free(); + } + } + + protected void onInit() {} + + protected void onApplyUniforms(float partialTicks) {} + + protected void onRender() {} +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java new file mode 100644 index 000000000..509c9e872 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java @@ -0,0 +1,110 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; + +import java.util.stream.Collectors; + +import com.google.common.collect.ImmutableList; + +import it.unimi.dsi.fastutil.ints.IntArrayList; +import it.unimi.dsi.fastutil.ints.IntList; + +/** + * This is used to represent a single vertex + * stored in GPU memory, + *

+ * A (almost) exact copy of Minecraft's + * VertexFormat class, several methods + * were commented out since we didn't need them. + * + * @author James Seibel + * @version 12-9-2021 + */ +public class LodVertexFormat +{ + /** the format of data stored in the GPU buffers */ + public static final LodVertexFormat DH_VERTEX_FORMAT = VertexFormats.POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX; + + + private final ImmutableList elements; + private final IntList offsets = new IntArrayList(); + private final int byteSize; + + public LodVertexFormat(ImmutableList elementList) + { + this.elements = elementList; + int i = 0; + + for (LodVertexFormatElement LodVertexFormatElement : elementList) + { + this.offsets.add(i); + i += LodVertexFormatElement.getByteSize(); + } + + this.byteSize = i; + } + + public int getByteSize() + { + return this.byteSize; + } + + public ImmutableList getElements() + { + return this.elements; + } + + + // Forge added method + public int getOffset(int index) + { + return offsets.getInt(index); + } + + + + @Override + public String toString() { return "format: " + this.elements.size() + " elements: " + this.elements.stream().map(Object::toString).collect(Collectors.joining(" ")); } + + + @Override + public boolean equals(Object obj) + { + if (this == obj) + { + return true; + } + else if (obj != null && this.getClass() == obj.getClass()) + { + LodVertexFormat vertexFormat = (LodVertexFormat) obj; + return this.byteSize == vertexFormat.byteSize && this.elements.equals(vertexFormat.elements); + } + else + { + return false; + } + } + + @Override + public int hashCode() { return this.elements.hashCode(); } + + + +} \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java new file mode 100644 index 000000000..cdc7dc41a --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java @@ -0,0 +1,168 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; + +import org.lwjgl.opengl.GL32; + +/** + * This object is used to build LodVertexFormats. + *

+ * A (almost) exact copy of Minecraft's + * VertexFormatElement class.
+ * A number of things were removed from the original + * object since we didn't need them, specifically "usage". + * + * @author James Seibel + * @version 11-13-2021 + */ +public class LodVertexFormatElement +{ + private final LodVertexFormatElement.DataType dataType; + /** James isn't sure what index is for */ + private final int index; + private final int count; + private final int byteSize; + private final boolean isPadding; + + public LodVertexFormatElement(int newIndex, LodVertexFormatElement.DataType newType, int newCount, boolean isPadding) + { + this.dataType = newType; + this.index = newIndex; + this.count = newCount; + this.byteSize = newType.getSize() * this.count; + this.isPadding = isPadding; + } + + public final boolean getIsPadding() + { + return isPadding; + } + + public final LodVertexFormatElement.DataType getType() + { + return this.dataType; + } + + public final int getIndex() + { + return this.index; + } + + public final int getByteSize() + { + return this.byteSize; + } + + // added by Forge + public int getElementCount() + { + return count; + } + + + + public enum DataType + { + FLOAT(4, "Float", GL32.GL_FLOAT), + UBYTE(1, "Unsigned Byte", GL32.GL_UNSIGNED_BYTE), + BYTE(1, "Byte", GL32.GL_BYTE), + USHORT(2, "Unsigned Short", GL32.GL_UNSIGNED_SHORT), + SHORT(2, "Short", GL32.GL_SHORT), + UINT(4, "Unsigned Int", GL32.GL_UNSIGNED_INT), + INT(4, "Int", GL32.GL_INT); + + private final int size; + private final String name; + private final int glType; + + DataType(int sizeInBytes, String newName, int openGlDataType) + { + this.size = sizeInBytes; + this.name = newName; + this.glType = openGlDataType; + } + + public int getSize() + { + return this.size; + } + + public String getName() + { + return this.name; + } + + public int getGlType() + { + return this.glType; + } + } + + + + + @Override + public int hashCode() + { + int i = this.dataType.hashCode(); + i = 31 * i + this.index; + return 31 * i + this.count; + } + + @Override + public String toString() + { + return this.count + "," + this.dataType.getName(); + } + + @Override + public boolean equals(Object obj) + { + if (this == obj) + { + return true; + } + else if (obj != null && this.getClass() == obj.getClass()) + { + LodVertexFormatElement LodVertexFormatElement = (LodVertexFormatElement) obj; + if (this.count != LodVertexFormatElement.count) + { + return false; + } + else if (this.index != LodVertexFormatElement.index) + { + return false; + } + else if (this.dataType != LodVertexFormatElement.dataType) + { + return false; + } + else + { + return false; + } + } + else + { + return false; + } + } + +} \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java new file mode 100644 index 000000000..dc4e04e64 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java @@ -0,0 +1,50 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; + +import com.google.common.collect.ImmutableList; + +/** + * A (almost) exact copy of MC's + * DefaultVertexFormats class. + */ +public class VertexFormats +{ + public static final LodVertexFormatElement ELEMENT_POSITION = new LodVertexFormatElement(3, LodVertexFormatElement.DataType.USHORT, 3, false); + public static final LodVertexFormatElement ELEMENT_COLOR = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.UBYTE, 4, false); + public static final LodVertexFormatElement ELEMENT_BYTE_PADDING = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, true); + + public static final LodVertexFormatElement ELEMENT_LIGHT = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.UBYTE, 1, false); + public static final LodVertexFormatElement ELEMENT_IRIS_MATERIAL_INDEX = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, false); + public static final LodVertexFormatElement ELEMENT_IRIS_NORMAL_INDEX = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, false); + + + public static final LodVertexFormat POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX = new LodVertexFormat(ImmutableList.builder() + .add(ELEMENT_POSITION) + .add(ELEMENT_BYTE_PADDING) + .add(ELEMENT_LIGHT) + .add(ELEMENT_COLOR) + .add(ELEMENT_IRIS_MATERIAL_INDEX) + .add(ELEMENT_IRIS_NORMAL_INDEX) + .add(ELEMENT_BYTE_PADDING) + .add(ELEMENT_BYTE_PADDING) // padding is to make sure the format is a multiple of 4 + .build()); + +} From 3a5d6e73708f6fa22770169669b0103e15ce07ca Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 16:31:32 -0500 Subject: [PATCH 45/72] Add RenderThreadTaskHandler --- .../common/AbstractModInitializer.java | 5 +-- .../BlazeGenericObjectVertexContainer.java | 11 ++++--- .../common/util/ILightTextureMarker.java | 32 ------------------- .../minecraft/MinecraftClientWrapper.java | 5 +-- coreSubProjects | 2 +- 5 files changed, 13 insertions(+), 42 deletions(-) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/util/ILightTextureMarker.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java index 821274c31..c7f7ac8ef 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java @@ -18,7 +18,8 @@ import com.seibel.distanthorizons.core.enums.MinecraftTextFormat; import com.seibel.distanthorizons.core.jar.ModJarInfo; import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModChecker; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; @@ -67,7 +68,7 @@ public abstract class AbstractModInitializer public void onInitializeClient() { - GLProxy.queueRunningOnRenderThread(() -> { DependencySetup.createRenderBindings(); }); + RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> { DependencySetup.createRenderBindings(); }); DependencySetup.createClientBindings(); this.createInitialClientBindings(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index 6384e970c..190c44f37 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -8,10 +8,11 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.glObject.GLEnums; -import com.seibel.distanthorizons.core.render.glObject.GLProxy; -import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; import org.lwjgl.opengl.GL32; @@ -258,7 +259,7 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu @Override public void close() { - GLProxy.queueRunningOnRenderThread(() -> + RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> { if (this.vboGpuBuffer != null) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/util/ILightTextureMarker.java b/common/src/main/java/com/seibel/distanthorizons/common/util/ILightTextureMarker.java deleted file mode 100644 index 3e92b5ffb..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/util/ILightTextureMarker.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.util; - -/** - * Added to MC's dynamic textures via mixins - * in order to denote whether a texture is a lightmap or not.

- * - * If not done any dynamic texture could be used as the lightmap - * which causes some weird rendering bugs. - */ -public interface ILightTextureMarker -{ - void markLightTexture(); -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java index 5227fbb3a..de8442cd0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java @@ -24,7 +24,8 @@ import java.io.File; import com.mojang.blaze3d.platform.Window; import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure; -import com.seibel.distanthorizons.core.render.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.coreapi.ModInfo; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -225,7 +226,7 @@ public class MinecraftClientWrapper implements IMinecraftClientWrapper, IMinecra player.displayClientMessage(net.minecraft.network.chat.Component.translatable(string), /*isOverlay*/false); #else - GLProxy.queueRunningOnRenderThread(() -> + RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> { player.displayClientMessage(net.minecraft.network.chat.Component.translatable(string), /*isOverlay*/false); }); diff --git a/coreSubProjects b/coreSubProjects index 8240101a4..82c832a4a 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 8240101a461472c8de1ba845deea28d69bfe3aeb +Subproject commit 82c832a4af4fdc88454d6924c2e1a1dc33cf33a3 From 23d3e440027737d2528cb8adc813a59c56dcda1d Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 16:34:34 -0500 Subject: [PATCH 46/72] change where vertex size is found --- .../common/render/blaze/McLodRenderer.java | 8 ++++---- coreSubProjects | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 129a6dd43..0f7388d84 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -30,9 +30,9 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.pos.DhSectionPos; -import com.seibel.distanthorizons.core.render.glObject.GLEnums; -import com.seibel.distanthorizons.core.render.glObject.buffer.QuadElementBuffer; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -154,7 +154,7 @@ public class McLodRenderer implements IMcLodRenderer //endregion @Override - public int getVertexSize() { return this.vertexFormat.getVertexSize(); } + public int getVertexByteSize() { return this.vertexFormat.getVertexSize(); } diff --git a/coreSubProjects b/coreSubProjects index 82c832a4a..67b2467be 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 82c832a4af4fdc88454d6924c2e1a1dc33cf33a3 +Subproject commit 67b2467beee770c7498c19a7eb89a5bc5276c999 From 4ceecdfb09a67ffdd444961c9598548af197b07e Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 17:35:52 -0500 Subject: [PATCH 47/72] update debug wireframe renderer --- .../blaze/BlazeDebugWireframeRenderer.java | 45 +++---- .../blaze/BlazeDhGenericObjectRenderer.java | 8 +- .../common/render/blaze/McLodRenderer.java | 5 +- .../BlazeDhFarFadeRenderer.java | 2 +- .../common/render/nativeGl/DebugRenderer.java | 123 +++--------------- .../common/render/nativeGl/LodRenderer.java | 3 +- .../common/wrappers/DependencySetup.java | 10 +- .../common/wrappers/WrapperFactory.java | 2 +- .../minecraft/MinecraftGLWrapper.java | 28 +--- .../common/wrappers/misc/LightMapWrapper.java | 13 +- coreSubProjects | 2 +- 11 files changed, 65 insertions(+), 176 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 7a92769c4..04055f285 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -38,13 +38,12 @@ import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUt import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.renderer.DebugRenderer; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcDebugRenderer; import net.minecraft.resources.Identifier; import org.lwjgl.system.MemoryUtil; @@ -55,17 +54,15 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** - * TODO + * Handles rendering the wireframe particles + * that are used for seeing what the system's doing. */ -public class BlazeDebugWireframeRenderer implements IMcDebugRenderer +public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); - private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static BlazeDebugWireframeRenderer INSTANCE = new BlazeDebugWireframeRenderer(); @@ -140,6 +137,10 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer } private void createPipelines() { + VertexFormat vertexFormat = VertexFormat.builder() + .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) + .build(); + RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { pipelineBuilder.withCull(false); @@ -155,13 +156,17 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer pipelineBuilder.withUniform("uniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(BlazePostProcessUtil.createVertexFormat(), VertexFormat.Mode.DEBUG_LINES); + pipelineBuilder.withVertexFormat(vertexFormat, VertexFormat.Mode.DEBUG_LINES); } this.pipeline = pipelineBuilder.build(); } private void createBuffers() { + GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + + // box vertices ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); @@ -217,23 +222,8 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer //===========// //region - private Mat4f combinedMatrixThisFrame = new Mat4f(); - @Override - public void render(RenderParams renderParams, Collection boxCollection) - { - - this.combinedMatrixThisFrame = new Mat4f(renderParams.dhProjectionMatrix); - this.combinedMatrixThisFrame.multiply(renderParams.dhModelViewMatrix); - - for (DebugRenderer.BoxParticle box : boxCollection) - { - this.render(box.createNewRenderBox()); - } - } - - @Override - public void render(DebugRenderer.Box box) + public void render(Box box) { this.init(); @@ -249,6 +239,9 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer return; } + GpuDevice GPU_DEVICE = RenderSystem.getDevice(); + CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + // uniforms @@ -273,7 +266,7 @@ public class BlazeDebugWireframeRenderer implements IMcDebugRenderer box.maxPos.y - box.minPos.y, box.maxPos.z - box.minPos.z)); - Mat4f transformMatrix = this.combinedMatrixThisFrame.copy(); + Mat4f transformMatrix = this.dhMvmProjMatrixThisFrame.copy(); transformMatrix.multiply(boxTransform); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index ce1db4375..a4575e5df 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -51,10 +51,10 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.f3.F3Screen; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; -import com.seibel.distanthorizons.core.render.renderer.generic.GenericRenderObjectFactory; -import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.render.renderer.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java index 0f7388d84..0330a1c38 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java @@ -26,6 +26,7 @@ import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVerte import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -282,8 +283,8 @@ public class McLodRenderer implements IMcLodRenderer { if (this.indexBuffer == null) { - ByteBuffer buffer = MemoryUtil.memAlloc(LodBufferContainer.MAX_QUADS_PER_BUFFER * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6); - QuadElementBuffer.buildBuffer(LodBufferContainer.MAX_QUADS_PER_BUFFER, buffer, GL32.GL_UNSIGNED_INT); + ByteBuffer buffer = MemoryUtil.memAlloc(LodQuadBuilder.getMaxBufferByteSize() * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6); + QuadElementBuffer.buildBuffer(LodQuadBuilder.getMaxBufferByteSize(), buffer, GL32.GL_UNSIGNED_INT); // create buffer if needed diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index b1b949ca9..fef5c1da6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -40,7 +40,7 @@ import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeText import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.renderer.RenderParams; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFarFadeRenderer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java index e39876121..e7999132e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java @@ -25,46 +25,30 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.config.types.ConfigEntry; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.pos.DhSectionPos; -import com.seibel.distanthorizons.core.render.renderer.IDebugRenderable; import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcDebugRenderer; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.lwjgl.opengl.GL32; -import java.awt.*; -import java.lang.ref.WeakReference; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.concurrent.PriorityBlockingQueue; /** * Handles rendering the wireframe particles * that are used for seeing what the system's doing. */ -public class DebugRenderer +public class DebugRenderer extends AbstractDebugWireframeRenderer { public static DebugRenderer INSTANCE = new DebugRenderer(); public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() - .maxCountPerSecond(1) - .build(); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -75,15 +59,6 @@ public class DebugRenderer private AbstractVertexAttribute va; private boolean init = false; - // used when rendering - private Mat4f dhMvmProjMatrixThisFrame; - private Vec3f camPosFloatThisFrame; - - - private final IMcDebugRenderer.RendererLists rendererLists = new IMcDebugRenderer.RendererLists(); - private final PriorityBlockingQueue particles = new PriorityBlockingQueue<>(); - - /** A box from 0,0,0 to 1,1,1 */ @@ -173,19 +148,14 @@ public class DebugRenderer - - //===========// // rendering // //===========// //region - public void render(RenderParams renderEventParam) + @Override + public void renderPass(RenderParams renderParams) { - //this.dhMvmProjMatrixThisFrame = dhMvmProjMatrix; // TODO - Vec3d camPos = MC_RENDER.getCameraExactPosition(); - this.camPosFloatThisFrame = new Vec3f((float) camPos.x, (float) camPos.y, (float) camPos.z); - this.init(); GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); @@ -194,86 +164,27 @@ public class DebugRenderer this.basicShader.bind(); this.va.bind(); - this.outlineIndexBuffer.bind(); - //this.rendererLists.render(this); // TODO - - - // particle rendering - IMcDebugRenderer.BoxParticle head = null; - while ((head = this.particles.poll()) != null && head.isDead()) - { /* remove dead particles */ } - if (head != null) - { - // re-add the popped off head - this.particles.add(head); - } - - IMcDebugRenderer renderer = SingletonInjector.INSTANCE.get(IMcDebugRenderer.class); - renderer.render(renderEventParam, this.particles); + super.renderPass(renderParams); } + @Override @Deprecated // TODO this should add all the boxes to a list so we can render them as a batch instead of individual draw calls - public void renderBox(IMcDebugRenderer.Box box) + public void render(Box box) { - IMcDebugRenderer renderer = SingletonInjector.INSTANCE.get(IMcDebugRenderer.class); - renderer.render(box); + Mat4f boxTransform = Mat4f.createTranslateMatrix(box.minPos.x - this.camPosFloatThisFrame.x, box.minPos.y - this.camPosFloatThisFrame.y, box.minPos.z - this.camPosFloatThisFrame.z); + boxTransform.multiply(Mat4f.createScaleMatrix(box.maxPos.x - box.minPos.x, box.maxPos.y - box.minPos.y, box.maxPos.z - box.minPos.z)); + + Mat4f transformMatrix = this.dhMvmProjMatrixThisFrame.copy(); + transformMatrix.multiply(boxTransform); + this.basicShader.setUniform(this.basicShader.getUniformLocation("uTransform"), transformMatrix); + + this.basicShader.setUniform(this.basicShader.getUniformLocation("uColor"), box.color); + + GL32.glDrawElements(GL32.GL_LINES, BOX_OUTLINE_INDICES.length, GL32.GL_UNSIGNED_INT, 0); } - //public void render(Mat4f dhMvmProjMatrix) - //{ - // this.dhMvmProjMatrixThisFrame = dhMvmProjMatrix; - // Vec3d camPos = MC_RENDER.getCameraExactPosition(); - // this.camPosFloatThisFrame = new Vec3f((float) camPos.x, (float) camPos.y, (float) camPos.z); - // - // this.init(); - // - // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); - // GLMC.enableDepthTest(); - // - // this.basicShader.bind(); - // this.va.bind(); - // - // - // this.outlineIndexBuffer.bind(); - // this.rendererLists.render(this); - // - // - // // particle rendering - // BoxParticle head = null; - // while ((head = this.particles.poll()) != null && head.isDead()) - // { /* remove dead particles */ } - // if (head != null) - // { - // // re-add the popped off head - // this.particles.add(head); - // } - // - // - // // box rendering - // GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - // for (BoxParticle particle : this.particles) - // { - // // a new box is created each time since the height will be different based on the time it's lived - // this.renderBox(particle.createNewRenderBox()); - // } - //} - // - //public void renderBox(Box box) - //{ - // Mat4f boxTransform = Mat4f.createTranslateMatrix(box.minPos.x - this.camPosFloatThisFrame.x, box.minPos.y - this.camPosFloatThisFrame.y, box.minPos.z - this.camPosFloatThisFrame.z); - // boxTransform.multiply(Mat4f.createScaleMatrix(box.maxPos.x - box.minPos.x, box.maxPos.y - box.minPos.y, box.maxPos.z - box.minPos.z)); - // - // Mat4f transformMatrix = this.dhMvmProjMatrixThisFrame.copy(); - // transformMatrix.multiply(boxTransform); - // this.basicShader.setUniform(this.basicShader.getUniformLocation("uTransform"), transformMatrix); - // - // this.basicShader.setUniform(this.basicShader.getUniformLocation("uColor"), box.color); - // - // GL32.glDrawElements(GL32.GL_LINES, BOX_OUTLINE_INDICES.length, GL32.GL_UNSIGNED_INT, 0); - //} - //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java index e9a165109..a04372174 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java @@ -32,6 +32,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhF import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -516,7 +517,7 @@ public class LodRenderer this.lodRenderProgram = new DhTerrainShaderProgram(); this.quadIBO = new QuadElementBuffer(); - this.quadIBO.reserve(LodBufferContainer.MAX_QUADS_PER_BUFFER); + this.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); // create or get the frame buffer diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index b0afbc502..ec598c669 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,6 +19,7 @@ package com.seibel.distanthorizons.common.wrappers; +import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; @@ -26,12 +27,13 @@ import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogR import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanillaFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; -import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftServerWrapper; import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.config.IConfigGui; import com.seibel.distanthorizons.core.wrapperInterfaces.config.ILangWrapper; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftClientWrapper; @@ -40,7 +42,6 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.*; @@ -64,6 +65,7 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IVersionConstants.class, VersionConstants.INSTANCE); SingletonInjector.INSTANCE.bind(IWrapperFactory.class, WrapperFactory.INSTANCE); SingletonInjector.INSTANCE.bind(IKeyedClientLevelManager.class, KeyedClientLevelManager.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhApiCustomRenderObjectFactory.class, GenericRenderObjectFactory.INSTANCE); } public static void createServerBindings() @@ -74,8 +76,9 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMinecraftClientWrapper.class, MinecraftClientWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftClientWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE); - SingletonInjector.INSTANCE.bind(IMinecraftGLWrapper.class, MinecraftGLWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IConfigGui.class, ClassicConfigGUI.CONFIG_CORE_INTERFACE); + + SingletonInjector.INSTANCE.bind(AbstractDebugWireframeRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } public static void createRenderBindings() @@ -86,7 +89,6 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, BlazeDhSsaoRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, BlazeDhFogRenderer.INSTANCE); SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcDebugRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index add474398..038617ac3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -36,7 +36,7 @@ import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; -import com.seibel.distanthorizons.core.render.renderer.generic.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftGLWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftGLWrapper.java index 02eeed0e3..56a5c3429 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftGLWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftGLWrapper.java @@ -27,10 +27,8 @@ import com.mojang.blaze3d.opengl.GlStateManager; import com.seibel.distanthorizons.core.jar.EPlatform; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; -import org.lwjgl.opengl.GL15; import org.lwjgl.opengl.GL32; @@ -52,7 +50,7 @@ import org.lwjgl.opengl.GL32; * This may slow down some low end GPUs that are driver limited, * however James would rather have slow correct rendering vs fast broken rendering. */ -public class MinecraftGLWrapper implements IMinecraftGLWrapper +public class MinecraftGLWrapper { public static final MinecraftGLWrapper INSTANCE = new MinecraftGLWrapper(); @@ -68,14 +66,12 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // scissor // /** @see GL32#GL_SCISSOR_TEST */ - @Override public void enableScissorTest() { GL32.glEnable(GL32.GL_SCISSOR_TEST); GlStateManager._enableScissorTest(); } /** @see GL32#GL_SCISSOR_TEST */ - @Override public void disableScissorTest() { GL32.glDisable(GL32.GL_SCISSOR_TEST); @@ -94,14 +90,12 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // depth // /** @see GL32#GL_DEPTH_TEST */ - @Override public void enableDepthTest() { GL32.glEnable(GL32.GL_DEPTH_TEST); GlStateManager._enableDepthTest(); } /** @see GL32#GL_DEPTH_TEST */ - @Override public void disableDepthTest() { GL32.glDisable(GL32.GL_DEPTH_TEST); @@ -109,7 +103,6 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper } /** @see GL32#glDepthFunc(int) */ - @Override public void glDepthFunc(int func) { GL32.glDepthFunc(func); @@ -117,14 +110,12 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper } /** @see GL32#glDepthMask(boolean) */ - @Override public void enableDepthMask() { GL32.glDepthMask(true); GlStateManager._depthMask(true); } /** @see GL32#glDepthMask(boolean) */ - @Override public void disableDepthMask() { GL32.glDepthMask(false); @@ -135,14 +126,12 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // blending // /** @see GL32#GL_BLEND */ - @Override public void enableBlend() { GL32.glEnable(GL32.GL_BLEND); GlStateManager._enableBlend(); } /** @see GL32#GL_BLEND */ - @Override public void disableBlend() { GL32.glDisable(GL32.GL_BLEND); @@ -150,7 +139,6 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper } /** @see GL32#glBlendFunc */ - @Override public void glBlendFunc(int sfactor, int dfactor) { GL32.glBlendFunc(sfactor, dfactor); @@ -160,7 +148,6 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper #endif } /** @see GL32#glBlendFuncSeparate */ - @Override public void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha) { GL32.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); @@ -171,7 +158,6 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // frame buffers // /** @see GL32#glBindFramebuffer */ - @Override public void glBindFramebuffer(int target, int framebuffer) { GL32.glBindFramebuffer(target, framebuffer); @@ -182,12 +168,10 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // buffers // /** @see GL32#glGenBuffers() */ - @Override public int glGenBuffers() { return GL32.glGenBuffers(); } - /** @see GL32#glDeleteBuffers(int) */ - @Override + /** @see GL32#glDeleteBuffers(int) */ public void glDeleteBuffers(int buffer) { GL32.glDeleteBuffers(buffer); @@ -218,14 +202,12 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // culling // /** @see GL32#GL_CULL_FACE */ - @Override public void enableFaceCulling() { GL32.glEnable(GL32.GL_CULL_FACE); GlStateManager._enableCull(); } /** @see GL32#GL_CULL_FACE */ - @Override public void disableFaceCulling() { GL32.glDisable(GL32.GL_CULL_FACE); @@ -236,27 +218,22 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper // textures // /** @see GL32#glGenTextures() */ - @Override public int glGenTextures() { return GlStateManager._genTexture(); } /** @see GL32#glDeleteTextures(int) */ - @Override public void glDeleteTextures(int texture) { GlStateManager._deleteTexture(texture); } /** @see GL32#glActiveTexture(int) */ - @Override public void glActiveTexture(int textureId) { GL32.glActiveTexture(textureId); GlStateManager._activeTexture(textureId); } - @Override public int getActiveTexture() { return GL32.glGetInteger(GL32.GL_TEXTURE_BINDING_2D); } /** * Always binds to {@link GL32#GL_TEXTURE_2D} * @see GL32#glBindTexture(int, int) */ - @Override public void glBindTexture(int texture) { GL32.glBindTexture(GL32.GL_TEXTURE_2D, texture); @@ -265,5 +242,4 @@ public class MinecraftGLWrapper implements IMinecraftGLWrapper - } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 9ae35a965..286fbe03b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -22,9 +22,8 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftGLWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import org.lwjgl.opengl.GL32; @@ -36,9 +35,15 @@ import java.nio.ByteBuffer; public class LightMapWrapper implements ILightMapWrapper { - private static final IMinecraftGLWrapper GLMC = SingletonInjector.INSTANCE.get(IMinecraftGLWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; private static final DhLogger LOGGER = new DhLoggerBuilder().build(); + /** + * which texture index IE 0,1,2... the lightmap will be bound to.
+ * Related to but different from {@link GL32#GL_TEXTURE0}. + */ + public static final int GL_BOUND_INDEX = 0; + private int textureId = 0; private GpuTexture gpuTexture = null; @@ -124,7 +129,7 @@ public class LightMapWrapper implements ILightMapWrapper @Override public void bind() { - GLMC.glActiveTexture(GL32.GL_TEXTURE0 + ILightMapWrapper.BOUND_INDEX); + GLMC.glActiveTexture(GL32.GL_TEXTURE0 + LightMapWrapper.GL_BOUND_INDEX); GLMC.glBindTexture(this.textureId); } diff --git a/coreSubProjects b/coreSubProjects index 67b2467be..49e34d78a 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 67b2467beee770c7498c19a7eb89a5bc5276c999 +Subproject commit 49e34d78a521e3f795b06eb556025aa458dc2bb0 From 485c3dedb313dc9fbbdc65e4afcee497e26e5575 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 17:40:06 -0500 Subject: [PATCH 48/72] remove deprication warnings --- .../render/blaze/BlazeDebugWireframeRenderer.java | 10 ++++++---- .../common/render/nativeGl/DebugRenderer.java | 1 - coreSubProjects | 2 +- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 04055f285..5215d6558 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -239,8 +239,10 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer return; } - GpuDevice GPU_DEVICE = RenderSystem.getDevice(); - CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); + // delayed getters since this class may be initialized before + // the GPU device has been set + GpuDevice gpuDevice = RenderSystem.getDevice(); + CommandEncoder commandEncoder = gpuDevice.createCommandEncoder(); @@ -287,14 +289,14 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer this.uniformBuffer = UniformHandler.createBuffer("uniformBlock", uniformBufferSize, this.uniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.uniformBuffer, 0, uniformBufferSize); - COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); + commandEncoder.writeToBuffer(bufferSlice, buffer); } // render // - try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( + try (RenderPass renderPass = commandEncoder.createRenderPass( this::getRenderPassName, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java index e7999132e..7cc016b57 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java @@ -170,7 +170,6 @@ public class DebugRenderer extends AbstractDebugWireframeRenderer } @Override - @Deprecated // TODO this should add all the boxes to a list so we can render them as a batch instead of individual draw calls public void render(Box box) { Mat4f boxTransform = Mat4f.createTranslateMatrix(box.minPos.x - this.camPosFloatThisFrame.x, box.minPos.y - this.camPosFloatThisFrame.y, box.minPos.z - this.camPosFloatThisFrame.z); diff --git a/coreSubProjects b/coreSubProjects index 49e34d78a..2ea3d645e 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 49e34d78a521e3f795b06eb556025aa458dc2bb0 +Subproject commit 2ea3d645e81f955de253a5a290c53fc5987c1d8e From 6748ec25ff3f0f8b8d6136b3974af7ff91d35e05 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 18:59:29 -0500 Subject: [PATCH 49/72] Rename and reorganize render pass interfaces --- .../blaze/BlazeDebugWireframeRenderer.java | 11 ++++------- .../blaze/BlazeDhGenericObjectRenderer.java | 16 ++++++++-------- ...derer.java => BlazeDhTerrainRenderer.java} | 19 +++++++++---------- .../BlazeGenericObjectVertexContainer.java | 9 ++++----- .../BlazeDhFarFadeRenderer.java | 16 ++++++++-------- .../postProcessing/BlazeDhFogRenderer.java | 12 ++++++------ .../postProcessing/BlazeDhSsaoRenderer.java | 14 +++++++------- .../BlazeVanillaFadeRenderer.java | 14 +++++++------- .../blaze/test/BlazeDhTestRenderer.java | 4 ++-- .../buffer/BlazeVertexBufferWrapper.java | 2 +- .../uniform/BlazeLodUniformBufferWrapper.java | 2 +- .../uniform/UniformBufferWrapper.java | 2 +- .../common/render/nativeGl/LodRenderer.java | 9 ++++----- .../NativeGlGenericObjectVertexContainer.java | 6 ++---- ....java => OpenGlGenericObjectRenderer.java} | 7 +++---- .../nativeGl/generic/RenderableBoxGroup.java | 8 ++++---- .../common/wrappers/DependencySetup.java | 16 ++++++++-------- .../common/wrappers/WrapperFactory.java | 12 ++++++------ coreSubProjects | 2 +- 19 files changed, 86 insertions(+), 95 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{McLodRenderer.java => BlazeDhTerrainRenderer.java} (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/{GenericObjectRenderer.java => OpenGlGenericObjectRenderer.java} (98%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 5215d6558..ea99296f2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -33,12 +33,10 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; -import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; @@ -49,7 +47,6 @@ import org.lwjgl.system.MemoryUtil; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.util.Collection; import java.util.OptionalDouble; import java.util.OptionalInt; @@ -227,8 +224,8 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer { this.init(); - if (McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -298,9 +295,9 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer try (RenderPass renderPass = commandEncoder.createRenderPass( this::getRenderPassName, - McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, + BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { // Bind instance data // diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index a4575e5df..0fc61b3e5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -53,14 +53,14 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.ModInfo; import net.minecraft.resources.Identifier; @@ -80,7 +80,7 @@ import java.util.concurrent.ConcurrentHashMap; * @see IDhApiCustomRenderRegister * @see DhApiRenderableBox */ -public class BlazeDhGenericObjectRenderer implements IMcGenericRenderer +public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -346,8 +346,8 @@ public class BlazeDhGenericObjectRenderer implements IMcGenericRenderer //#endregion - if (McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -397,7 +397,7 @@ public class BlazeDhGenericObjectRenderer implements IMcGenericRenderer boxGroup.tryUpdateInstancedDataAsync(); // skip groups that haven't been uploaded yet - if (boxGroup.vertexBufferContainer.getState() != IGenericObjectVertexBufferContainer.EState.RENDER) + if (boxGroup.vertexBufferContainer.getState() != IDhGenericObjectVertexBufferContainer.EState.RENDER) { continue; } @@ -497,9 +497,9 @@ public class BlazeDhGenericObjectRenderer implements IMcGenericRenderer try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( this::getRenderPassName, - McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, + BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index 0330a1c38..c32b5122c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/McLodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -40,8 +40,8 @@ import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcLodRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import org.lwjgl.opengl.GL32; @@ -52,19 +52,15 @@ import java.nio.ByteOrder; import java.util.OptionalDouble; import java.util.OptionalInt; -/** - * Renders a TODO - */ -public class McLodRenderer implements IMcLodRenderer +/** Renders rendering DH's LOD terrain. */ +public class BlazeDhTerrainRenderer implements IDhTerrainRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final McLodRenderer INSTANCE = new McLodRenderer(); + public static final BlazeDhTerrainRenderer INSTANCE = new BlazeDhTerrainRenderer(); private BlazeDhApplyRenderer applyRenderer; @@ -89,7 +85,7 @@ public class McLodRenderer implements IMcLodRenderer //=============// //region - private McLodRenderer() + private BlazeDhTerrainRenderer() { this.vertexFormat = VertexFormat.builder() .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) @@ -307,6 +303,9 @@ public class McLodRenderer implements IMcLodRenderer this.dhDepthTextureWrapper.tryCreateOrResize(); this.dhColorTextureWrapper.tryCreateOrResize(); + + + // render pass setup { profiler.popPush("setup"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index 190c44f37..0620eab58 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -9,9 +9,8 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; import org.lwjgl.opengl.GL32; @@ -25,7 +24,7 @@ import java.util.List; * * @see RenderableBoxGroup */ -public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBufferContainer +public class BlazeGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -69,9 +68,9 @@ public class BlazeGenericObjectVertexContainer implements IGenericObjectVertexBu private EState state = EState.NEW; @Override - public IGenericObjectVertexBufferContainer.EState getState() { return this.state; } + public IDhGenericObjectVertexBufferContainer.EState getState() { return this.state; } @Override - public void setState(IGenericObjectVertexBufferContainer.EState state) { this.state = state; } + public void setState(IDhGenericObjectVertexBufferContainer.EState state) { this.state = state; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index fef5c1da6..678c772cc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -32,7 +32,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -43,7 +43,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFarFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhFarFadeRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -55,7 +55,7 @@ import java.util.OptionalInt; /** * Fades out DH's far clip plane */ -public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer +public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -136,8 +136,8 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -191,7 +191,7 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer this.renderFadeToTexture(); - BlazeDhCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, McLodRenderer.INSTANCE.dhColorTextureWrapper); + BlazeDhCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper); } @@ -208,8 +208,8 @@ public class BlazeDhFarFadeRenderer implements IMcFarFadeRenderer renderPass.bindTexture("uMcColorTexture", this.mcColorTextureViewWrapper.textureView, this.mcColorTextureViewWrapper.textureSampler); // DH textures - renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); - renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index 76514442d..8dab2b0dd 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -39,7 +39,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -52,7 +52,7 @@ import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcFogRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhFogRenderer; import net.minecraft.resources.Identifier; import java.awt.*; @@ -64,7 +64,7 @@ import java.util.OptionalInt; /** * Renders fog onto the LODs. */ -public class BlazeDhFogRenderer implements IMcFogRenderer +public class BlazeDhFogRenderer implements IDhFogRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -154,8 +154,8 @@ public class BlazeDhFogRenderer implements IMcFogRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -308,7 +308,7 @@ public class BlazeDhFogRenderer implements IMcFogRenderer this.renderFogToTexture(); - this.applyRenderer.render(this.fogColorTextureWrapper.texture, McLodRenderer.INSTANCE.dhDepthTextureWrapper.texture, McLodRenderer.INSTANCE.dhColorTextureWrapper.texture); + this.applyRenderer.render(this.fogColorTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.texture); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index b10678a9c..16cd9569a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -36,7 +36,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -47,7 +47,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcSsaoRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhSsaoRenderer; import net.minecraft.resources.Identifier; import java.nio.ByteBuffer; @@ -56,7 +56,7 @@ import java.util.OptionalDouble; import java.util.OptionalInt; /** Renders SSAO to the DH LODs. */ -public class BlazeDhSsaoRenderer implements IMcSsaoRenderer +public class BlazeDhSsaoRenderer implements IDhSsaoRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -145,8 +145,8 @@ public class BlazeDhSsaoRenderer implements IMcSsaoRenderer this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -244,7 +244,7 @@ public class BlazeDhSsaoRenderer implements IMcSsaoRenderer this.renderSsaoToTexture(); this.applyRenderer.setUniform("applyFragUniformBlock", this.applyFragUniformBuffer); - this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, McLodRenderer.INSTANCE.dhDepthTextureWrapper.texture, McLodRenderer.INSTANCE.dhColorTextureWrapper.texture); + this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.texture); } @@ -257,7 +257,7 @@ public class BlazeDhSsaoRenderer implements IMcSsaoRenderer /*depthTexture*/ null, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index 235147a24..cddb258a4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -32,7 +32,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; @@ -45,7 +45,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcVanillaFadeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhVanillaFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -59,7 +59,7 @@ import java.util.OptionalInt; * Fades the vanilla chunks * into DH's LODs. */ -public class BlazeVanillaFadeRenderer implements IMcVanillaFadeRenderer +public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -144,8 +144,8 @@ public class BlazeVanillaFadeRenderer implements IMcVanillaFadeRenderer { this.tryInit(); - if (McLodRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || McLodRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -236,8 +236,8 @@ public class BlazeVanillaFadeRenderer implements IMcVanillaFadeRenderer renderPass.bindTexture("uMcDepthTexture", this.mcDepthTextureWrapper.textureView, this.mcDepthTextureWrapper.textureSampler); renderPass.bindTexture("uCombinedMcDhColorTexture", this.mcColorTextureWrapper.textureView, this.mcColorTextureWrapper.textureSampler); - renderPass.bindTexture("uDhDepthTexture", McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureView, McLodRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); - renderPass.bindTexture("uDhColorTexture", McLodRenderer.INSTANCE.dhColorTextureWrapper.textureView, McLodRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java index a86d21719..e25f4e33e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java @@ -33,7 +33,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -47,7 +47,7 @@ import java.util.OptionalInt; * to the center of the screen to confirm DH's * apply shader is running correctly */ -public class BlazeDhTestRenderer implements IMcTestRenderer +public class BlazeDhTestRenderer implements IDhTestTriangleRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java index 862d9bc6f..aaf792df3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java @@ -5,7 +5,7 @@ import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import java.nio.ByteBuffer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java index 91578c52b..826f928c8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java @@ -4,7 +4,7 @@ import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.util.math.Vec3f; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; import java.nio.ByteBuffer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java index fabb3a8ae..d0c448584 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java @@ -7,7 +7,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IUniformBufferWrapper; import java.nio.ByteBuffer; import java.nio.ByteOrder; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java index a04372174..2e1784bba 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java @@ -31,7 +31,6 @@ import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.Dh import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFadeRenderer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -51,8 +50,8 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrap import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcTestRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; import com.seibel.distanthorizons.core.util.math.Vec3f; @@ -160,7 +159,7 @@ public class LodRenderer } RenderBufferHandler renderBufferHandler = renderParams.renderBufferHandler; - IMcGenericRenderer genericRenderer = renderParams.genericRenderer; + IDhGenericRenderer genericRenderer = renderParams.genericRenderer; ILightMapWrapper lightmap = renderParams.lightmap; @@ -703,7 +702,7 @@ public class LodRenderer { // basic quad rendering - IMcTestRenderer testRenderer = SingletonInjector.INSTANCE.get(IMcTestRenderer.class); + IDhTestTriangleRenderer testRenderer = SingletonInjector.INSTANCE.get(IDhTestTriangleRenderer.class); testRenderer.render(); //TestRenderer.INSTANCE.render(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java index 87ec6eb80..6d232f05c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java @@ -2,12 +2,10 @@ package com.seibel.distanthorizons.common.render.nativeGl.generic; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.util.LodUtil; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import org.lwjgl.opengl.GL32; import java.awt.*; @@ -18,7 +16,7 @@ import java.util.List; * * @see RenderableBoxGroup */ -public class NativeGlGenericObjectVertexContainer implements IGenericObjectVertexBufferContainer +public class NativeGlGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java index 4a449ee95..86c6d7660 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java @@ -45,7 +45,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRen import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.ISodiumAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; import com.seibel.distanthorizons.coreapi.ModInfo; @@ -65,12 +65,11 @@ import java.util.concurrent.ConcurrentHashMap; * @see IDhApiCustomRenderRegister * @see DhApiRenderableBox */ -public class GenericObjectRenderer implements IMcGenericRenderer +public class OpenGlGenericObjectRenderer implements IDhGenericRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final ISodiumAccessor SODIUM = ModAccessorInjector.INSTANCE.get(ISodiumAccessor.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); @@ -173,7 +172,7 @@ public class GenericObjectRenderer implements IMcGenericRenderer //=============// //region - public GenericObjectRenderer() { } + public OpenGlGenericObjectRenderer() { } public void init() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java index 2e354598e..83882fb36 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java @@ -14,7 +14,7 @@ import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker; import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import org.jetbrains.annotations.Nullable; import java.io.Closeable; @@ -67,9 +67,9 @@ public class RenderableBoxGroup public Consumer afterRenderFunc; // instance data - public IGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + public IDhGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); /** double buffering for thread safety and to prevent locking the render thread during update */ - private IGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + private IDhGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); @@ -200,7 +200,7 @@ public class RenderableBoxGroup this.altVertexBufferContainer.uploadDataToGpu(); // swap VBO references for rendering - IGenericObjectVertexBufferContainer temp = this.vertexBufferContainer; + IDhGenericObjectVertexBufferContainer temp = this.vertexBufferContainer; this.vertexBufferContainer = this.altVertexBufferContainer; this.altVertexBufferContainer = temp; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index ec598c669..639da81ab 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -21,7 +21,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; -import com.seibel.distanthorizons.common.render.blaze.McLodRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; @@ -44,7 +44,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.*; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; /** * Binds all necessary dependencies, so we @@ -83,12 +83,12 @@ public class DependencySetup public static void createRenderBindings() { - SingletonInjector.INSTANCE.bind(IMcTestRenderer.class, BlazeDhTestRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcVanillaFadeRenderer.class, BlazeVanillaFadeRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcLodRenderer.class, McLodRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcSsaoRenderer.class, BlazeDhSsaoRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcFogRenderer.class, BlazeDhFogRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IMcFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhTestTriangleRenderer.class, BlazeDhTestRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhVanillaFadeRenderer.class, BlazeVanillaFadeRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhTerrainRenderer.class, BlazeDhTerrainRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhSsaoRenderer.class, BlazeDhSsaoRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhFogRenderer.class, BlazeDhFogRenderer.INSTANCE); + SingletonInjector.INSTANCE.bind(IDhFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 038617ac3..3f5facabb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -36,14 +36,14 @@ import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.block.IBlockStateWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.chunk.IChunkWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.ILodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IMcGenericRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IBiomeWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.world.ILevelWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.worldGeneration.IBatchGeneratorEnvironmentWrapper; @@ -225,10 +225,10 @@ public class WrapperFactory implements IWrapperFactory public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new BlazeLodUniformBufferWrapper(); } @Override - public IGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } + public IDhGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } @Override - public IMcGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } + public IDhGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } //endregion diff --git a/coreSubProjects b/coreSubProjects index 2ea3d645e..1dd244e88 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 2ea3d645e81f955de253a5a290c53fc5987c1d8e +Subproject commit 1dd244e889498ac84fb227a49b2c026e1de5b90e From 294013eff01cd36b4f36858e08d34075cc33fcb7 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Mon, 9 Mar 2026 20:14:54 -0500 Subject: [PATCH 50/72] Add rendering API definition --- .../common/AbstractModInitializer.java | 23 +++++++- .../blaze/BlazeDhRenderApiDefinition.java | 39 +++++++++++++ .../postProcessing/BlazeDhSsaoRenderer.java | 2 +- ....java => BlazeDhTestTriangleRenderer.java} | 6 +- .../nativeGl/OpenGlDhRenderApiDefinition.java | 31 ++++++++++ .../nativeGl/generic/RenderableBoxGroup.java | 4 +- .../common/wrappers/DependencySetup.java | 57 +++++++++++++------ .../common/wrappers/WrapperFactory.java | 42 +++++++++----- coreSubProjects | 2 +- 9 files changed, 164 insertions(+), 42 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/{BlazeDhTestRenderer.java => BlazeDhTestTriangleRenderer.java} (96%) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java index c7f7ac8ef..538f16fdd 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java @@ -18,8 +18,6 @@ import com.seibel.distanthorizons.core.enums.MinecraftTextFormat; import com.seibel.distanthorizons.core.jar.ModJarInfo; import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModChecker; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; @@ -47,6 +45,7 @@ public abstract class AbstractModInitializer //==================// // abstract methods // //==================// + //region protected abstract void createInitialSharedBindings(); protected abstract void createInitialClientBindings(); @@ -60,15 +59,17 @@ public abstract class AbstractModInitializer protected abstract void subscribeServerStartingEvent(Consumer eventHandler); protected abstract void runDelayedSetup(); + //endregion + //===================// // initialize events // //===================// + //region public void onInitializeClient() { - RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> { DependencySetup.createRenderBindings(); }); DependencySetup.createClientBindings(); this.createInitialClientBindings(); @@ -96,6 +97,7 @@ public abstract class AbstractModInitializer #endif this.subscribeClientStartedEvent(this::postInit); + this.subscribeClientStartedEvent(this::postClientInit); } public void onInitializeServer() @@ -135,11 +137,14 @@ public abstract class AbstractModInitializer }); } + //endregion + //===========================// // inner initializer methods // //===========================// + //region private void startup() { @@ -212,11 +217,16 @@ public abstract class AbstractModInitializer ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterDhInitEvent.class, null); } + private void postClientInit() { DependencySetup.setRenderingApiBindings(); } + + //endregion + //==================================// // mod partial compatibility checks // //==================================// + //region /** * Some mods will work with a few tweaks @@ -305,15 +315,22 @@ public abstract class AbstractModInitializer } + //endregion + //================// // helper classes // //================// + //region public interface IEventProxy { void registerEvents(); } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java new file mode 100644 index 000000000..73c7dc816 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -0,0 +1,39 @@ +package com.seibel.distanthorizons.common.render.blaze; + +import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; +import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanillaFadeRenderer; +import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestTriangleRenderer; +import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; +import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; + +public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition +{ + + @Override public IDhTerrainRenderer getTerrainRenderer() { return BlazeDhTerrainRenderer.INSTANCE; } + @Override public IDhSsaoRenderer getSsaoRenderer() { return BlazeDhSsaoRenderer.INSTANCE; } + @Override public IDhFogRenderer getFogRenderer() { return BlazeDhFogRenderer.INSTANCE; } + @Override public IDhFarFadeRenderer getFarFadeRenderer() { return BlazeDhFarFadeRenderer.INSTANCE; } + @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return BlazeDebugWireframeRenderer.INSTANCE; } + + @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return BlazeVanillaFadeRenderer.INSTANCE; } + @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return BlazeDhTestTriangleRenderer.INSTANCE; } + + @Override public IDhGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } + + + @Override public IVertexBufferWrapper createVboWrapper(String name) { return new BlazeVertexBufferWrapper(name); } + @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new BlazeLodUniformBufferWrapper(); } + @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new BlazeGenericObjectVertexContainer(); } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index 16cd9569a..384522bb1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -58,7 +58,7 @@ import java.util.OptionalInt; /** Renders SSAO to the DH LODs. */ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer { - public static final DhLogger LOGGER = new DhLoggerBuilder().build(); + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java similarity index 96% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java index e25f4e33e..697b7288e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java @@ -47,14 +47,14 @@ import java.util.OptionalInt; * to the center of the screen to confirm DH's * apply shader is running correctly */ -public class BlazeDhTestRenderer implements IDhTestTriangleRenderer +public class BlazeDhTestTriangleRenderer implements IDhTestTriangleRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); - public static final BlazeDhTestRenderer INSTANCE = new BlazeDhTestRenderer(); + public static final BlazeDhTestTriangleRenderer INSTANCE = new BlazeDhTestTriangleRenderer(); private RenderPipeline pipeline; private boolean init = false; @@ -70,7 +70,7 @@ public class BlazeDhTestRenderer implements IDhTestTriangleRenderer //=============// //region - private BlazeDhTestRenderer() { } + private BlazeDhTestTriangleRenderer() { } private void tryInit() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java new file mode 100644 index 000000000..a93b03f5a --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java @@ -0,0 +1,31 @@ +package com.seibel.distanthorizons.common.render.nativeGl; + +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; + +public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition +{ + + @Override public IDhTerrainRenderer getTerrainRenderer() { return null; } + @Override public IDhSsaoRenderer getSsaoRenderer() { return null; } + @Override public IDhFogRenderer getFogRenderer() { return null; } + @Override public IDhFarFadeRenderer getFarFadeRenderer() { return null; } + @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return null; } + + @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return null; } + @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return null; } + + @Override public IDhGenericRenderer createGenericRenderer() { return null; } + + + @Override public IVertexBufferWrapper createVboWrapper(String name) { return null; } + @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return null; } + @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return null; } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java index 83882fb36..c9a7adc99 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java @@ -67,9 +67,9 @@ public class RenderableBoxGroup public Consumer afterRenderFunc; // instance data - public IDhGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + public IDhGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createGenericObjectVboContainer(); /** double buffering for thread safety and to prevent locking the render thread during update */ - private IDhGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createInstancedVboContainer(); + private IDhGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createGenericObjectVboContainer(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 639da81ab..f6c1bfdd6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -19,21 +19,19 @@ package com.seibel.distanthorizons.common.wrappers; +import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; -import com.seibel.distanthorizons.common.render.blaze.BlazeDebugWireframeRenderer; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; -import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanillaFadeRenderer; -import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestRenderer; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhRenderApiDefinition; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhRenderApiDefinition; import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftServerWrapper; +import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; -import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.config.IConfigGui; import com.seibel.distanthorizons.core.wrapperInterfaces.config.ILangWrapper; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftClientWrapper; @@ -44,7 +42,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftSharedWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; /** * Binds all necessary dependencies, so we @@ -58,6 +56,9 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; */ public class DependencySetup { + protected static final DhLogger LOGGER = new DhLoggerBuilder().build(); + + public static void createSharedBindings() { @@ -77,18 +78,38 @@ public class DependencySetup SingletonInjector.INSTANCE.bind(IMinecraftSharedWrapper.class, MinecraftClientWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IMinecraftRenderWrapper.class, MinecraftRenderWrapper.INSTANCE); SingletonInjector.INSTANCE.bind(IConfigGui.class, ClassicConfigGUI.CONFIG_CORE_INTERFACE); - - SingletonInjector.INSTANCE.bind(AbstractDebugWireframeRenderer.class, BlazeDebugWireframeRenderer.INSTANCE); } - public static void createRenderBindings() + public static void setRenderingApiBindings() { - SingletonInjector.INSTANCE.bind(IDhTestTriangleRenderer.class, BlazeDhTestRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IDhVanillaFadeRenderer.class, BlazeVanillaFadeRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IDhTerrainRenderer.class, BlazeDhTerrainRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IDhSsaoRenderer.class, BlazeDhSsaoRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IDhFogRenderer.class, BlazeDhFogRenderer.INSTANCE); - SingletonInjector.INSTANCE.bind(IDhFarFadeRenderer.class, BlazeDhFarFadeRenderer.INSTANCE); + EDhApiRenderApi renderingApiEnum = Config.Client.Advanced.Graphics.Experimental.renderingApi.get(); + if (renderingApiEnum == EDhApiRenderApi.AUTO) + { + #if MC_VER < MC_1_21_11 + renderingApiEnum = EDhApiRenderApi.OPEN_GL; + #else + renderingApiEnum = EDhApiRenderApi.BLAZE_3D; + #endif + } + + LOGGER.info("Setting DH Rendering API to: ["+renderingApiEnum+"]."); + + AbstractDhRenderApiDefinition renderDefinition; + if (renderingApiEnum == EDhApiRenderApi.OPEN_GL) + { + renderDefinition = new OpenGlDhRenderApiDefinition(); + } + else if (renderingApiEnum == EDhApiRenderApi.BLAZE_3D) + { + renderDefinition = new BlazeDhRenderApiDefinition(); + } + else + { + throw new IllegalStateException("No ["+ AbstractDhRenderApiDefinition.class.getSimpleName()+"] concrete implementation found for the value: ["+renderingApiEnum+"]."); + } + renderDefinition.bindRenderers(); } + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java index 3f5facabb..44a9c3662 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/WrapperFactory.java @@ -24,18 +24,16 @@ import com.seibel.distanthorizons.api.interfaces.block.IDhApiBlockStateWrapper; import com.seibel.distanthorizons.api.interfaces.override.worldGenerator.IDhApiWorldGenerator; import com.seibel.distanthorizons.api.interfaces.world.IDhApiLevelWrapper; import com.seibel.distanthorizons.api.interfaces.factories.IDhApiWrapperFactory; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhGenericObjectRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.block.BiomeWrapper; import com.seibel.distanthorizons.common.wrappers.block.BlockStateWrapper; import com.seibel.distanthorizons.common.wrappers.chunk.ChunkWrapper; import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; import com.seibel.distanthorizons.common.wrappers.world.ServerLevelWrapper; import com.seibel.distanthorizons.common.wrappers.worldGeneration.BatchGenerationEnvironment; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.level.IDhLevel; import com.seibel.distanthorizons.core.level.IDhServerLevel; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; @@ -69,6 +67,28 @@ public class WrapperFactory implements IWrapperFactory + //=====================// + // internal properties // + //=====================// + //region + + private AbstractDhRenderApiDefinition renderDefinition; + private AbstractDhRenderApiDefinition getRenderDefinition() + { + // delayed get to make sure we don't accidentally set the variable before it's bound + if (this.renderDefinition != null) + { + return this.renderDefinition; + } + + this.renderDefinition = SingletonInjector.INSTANCE.get(AbstractDhRenderApiDefinition.class); + return this.renderDefinition; + } + + //endregion + + + //==============// // core methods // //==============// @@ -219,16 +239,10 @@ public class WrapperFactory implements IWrapperFactory } - @Override - public IVertexBufferWrapper createVboWrapper(String name) { return new BlazeVertexBufferWrapper(name); } - @Override - public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new BlazeLodUniformBufferWrapper(); } - - @Override - public IDhGenericObjectVertexBufferContainer createInstancedVboContainer() { return new BlazeGenericObjectVertexContainer(); } - - @Override - public IDhGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } + @Override public IVertexBufferWrapper createVboWrapper(String name) { return this.getRenderDefinition().createVboWrapper(name); } + @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return this.getRenderDefinition().createLodContainerUniformWrapper(); } + @Override public IDhGenericObjectVertexBufferContainer createGenericObjectVboContainer() { return this.getRenderDefinition().createGenericVboContainer(); } + @Override public IDhGenericRenderer createGenericRenderer() { return this.getRenderDefinition().createGenericRenderer(); } //endregion diff --git a/coreSubProjects b/coreSubProjects index 1dd244e88..559bad567 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 1dd244e889498ac84fb227a49b2c026e1de5b90e +Subproject commit 559bad5676d492b832fa6958e3c1ca57df42f1c8 From 3555133d7f639b6854f2380f4262eae0d59cf9e9 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 11:47:40 -0500 Subject: [PATCH 51/72] Add the option to use either Blaze3D or OpenGL rendering APIs --- build.gradle | 31 +- .../blaze/BlazeDhGenericObjectRenderer.java | 4 +- .../blaze/BlazeDhRenderApiDefinition.java | 1 + .../render/blaze/BlazeDhTerrainRenderer.java | 34 +- .../BlazeGenericObjectVertexContainer.java | 2 +- .../nativeGl/DhTerrainShaderProgram.java | 571 ++++++++++++- .../common/render/nativeGl/LodRenderer.java | 766 ------------------ ...java => OpenGlDebugWireframeRenderer.java} | 10 +- .../nativeGl/OpenGlDhRenderApiDefinition.java | 33 +- .../generic/GenericRenderObjectFactory.java | 75 -- .../generic/OpenGlGenericObjectRenderer.java | 24 +- ...> OpenGlGenericObjectVertexContainer.java} | 32 +- .../nativeGl/generic/RenderableBoxGroup.java | 361 --------- .../glObject/OpenGlDummyUniformData.java | 13 + .../nativeGl/glObject/buffer/GLBuffer.java | 29 +- .../glObject/buffer/GLVertexBuffer.java | 86 +- .../glObject/texture/DhFramebuffer.java | 55 -- .../nativeGl/postProcessing/ScreenQuad.java | 48 +- .../postProcessing/apply/DhApplyShader.java | 22 +- ...yShader.java => DhFarFadeApplyShader.java} | 7 +- ...deRenderer.java => DhFarFadeRenderer.java} | 54 +- ...DhFadeShader.java => DhFarFadeShader.java} | 15 +- .../{ => fade}/VanillaFadeRenderer.java | 46 +- .../fade/VanillaFadeShader.java | 19 +- .../{FogRenderer.java => DhFogRenderer.java} | 26 +- .../postProcessing/fog/FogApplyShader.java | 9 +- .../postProcessing/fog/FogShader.java | 7 +- ...{SSAORenderer.java => DhSSAORenderer.java} | 31 +- .../postProcessing/ssao/SSAOApplyShader.java | 8 +- .../postProcessing/ssao/SSAOShader.java | 11 +- ...derer.java => GlTestTriangleRenderer.java} | 13 +- .../common/wrappers/DependencySetup.java | 4 +- coreSubProjects | 2 +- .../mixins/client/MixinLightTexture.java | 9 +- .../mixins/client/MixinLightTexture.java | 9 +- 35 files changed, 965 insertions(+), 1502 deletions(-) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/{DebugRenderer.java => OpenGlDebugWireframeRenderer.java} (92%) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/{NativeGlGenericObjectVertexContainer.java => OpenGlGenericObjectVertexContainer.java} (94%) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/{FadeApplyShader.java => DhFarFadeApplyShader.java} (88%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/{DhFadeRenderer.java => DhFarFadeRenderer.java} (71%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/{DhFadeShader.java => DhFarFadeShader.java} (89%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/{ => fade}/VanillaFadeRenderer.java (84%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/{FogRenderer.java => DhFogRenderer.java} (89%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/{SSAORenderer.java => DhSSAORenderer.java} (86%) rename common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/{GlTestRenderer.java => GlTestTriangleRenderer.java} (88%) diff --git a/build.gradle b/build.gradle index c9c8b6001..df7c0ba84 100644 --- a/build.gradle +++ b/build.gradle @@ -268,11 +268,6 @@ subprojects { p -> // Netty implementation("io.netty:netty-buffer:${rootProject.netty_version}") - // Remember, for lwjgl dependencies that arent included in Minecraft, you need to also need to add it to the ShadowJar thing - forgeShadowMe("org.lwjgl:lwjgl-jawt:${rootProject.lwjgl_version}") { - exclude group: "org.lwjgl", module: "lwjgl" // This module is imported by Minecraft so exclude it - } - //==========================// @@ -320,11 +315,7 @@ subprojects { p -> relocate "com.seibel.distanthorizons.common", "loaderCommon.${p.name}.com.seibel.distanthorizons.common" // Move the loader files to a different location } def librariesLocation = "DistantHorizons.libraries" - - // LWJGL - // Only ever shadow the dependencies we use otherwise some stuff would break when running on an external client - relocate "org.lwjgl.system.jawt", "${librariesLocation}.lwjgl.system.jawt" - + // Compression (LZ4) relocate "net.jpountz", "${librariesLocation}.jpountz" @@ -629,26 +620,30 @@ allprojects { p -> if (p == project(":core")) { OperatingSystem os = org.gradle.nativeplatform.platform.internal.DefaultNativePlatform.currentOperatingSystem; - // Set the OS lwjgl is using to the current os + // Set the OS lwjgl is using to the current os project.ext.lwjglNatives = "natives-" + os.toFamilyName() - dependencies { // All of these dependencies are in Vanilla Minecraft, but we need to depend on it as we arent importing Minecraft in the core - // Imports most of lwjgl's libraries (well, only the ones that we need) + dependencies { + // All of these dependencies are in Vanilla Minecraft, but we need to depend on them as we arent importing Minecraft in the core + + // Imports most of lwjgl's libraries implementation platform("org.lwjgl:lwjgl-bom:${rootProject.lwjgl_version}") - // REMEMBER: Dont shadow stuff here, these are just the libs that are included in Minecraft so that the core can use + // REMEMBER: Don't shadow stuff here, these are just the libs that are included in Minecraft so that the core can use them implementation "org.lwjgl:lwjgl" implementation "org.lwjgl:lwjgl-assimp" implementation "org.lwjgl:lwjgl-glfw" - implementation "org.lwjgl:lwjgl-openal" - implementation "org.lwjgl:lwjgl-opengl" + // OpenGL is removed since DH now handles rendering in the "Common" project + // so we can use OpenGL for old MC versions and Blaze3D (IE Vulkan) for newer ones +// implementation "org.lwjgl:lwjgl-openal" +// implementation "org.lwjgl:lwjgl-opengl" implementation "org.lwjgl:lwjgl-stb" implementation "org.lwjgl:lwjgl-tinyfd" runtimeOnly "org.lwjgl:lwjgl::$lwjglNatives" runtimeOnly "org.lwjgl:lwjgl-assimp::$lwjglNatives" runtimeOnly "org.lwjgl:lwjgl-glfw::$lwjglNatives" - runtimeOnly "org.lwjgl:lwjgl-openal::$lwjglNatives" - runtimeOnly "org.lwjgl:lwjgl-opengl::$lwjglNatives" +// runtimeOnly "org.lwjgl:lwjgl-openal::$lwjglNatives" +// runtimeOnly "org.lwjgl:lwjgl-opengl::$lwjglNatives" runtimeOnly "org.lwjgl:lwjgl-stb::$lwjglNatives" runtimeOnly "org.lwjgl:lwjgl-tinyfd::$lwjglNatives" implementation "org.joml:joml:${rootProject.joml_version}" diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index 0fc61b3e5..56547fba9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -52,9 +52,9 @@ import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.RenderParams; -import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.render.renderer.GenericRenderObjectFactory; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.render.renderer.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java index 73c7dc816..79395445b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -17,6 +17,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition { + public String getApiName() { return "Blaze3D"; } @Override public IDhTerrainRenderer getTerrainRenderer() { return BlazeDhTerrainRenderer.INSTANCE; } @Override public IDhSsaoRenderer getSsaoRenderer() { return BlazeDhSsaoRenderer.INSTANCE; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index c32b5122c..2408ff194 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -65,7 +65,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer private BlazeDhApplyRenderer applyRenderer; - private VertexFormat vertexFormat; private RenderPipeline opaquePipeline; private RenderPipeline transparentPipeline; private boolean init = false; @@ -85,18 +84,7 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer //=============// //region - private BlazeDhTerrainRenderer() - { - this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) - .add("meta", DhBlazeVertexFormatUtil.META) - .add("vColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) - .add("irisMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) - .add("irisNormal", DhBlazeVertexFormatUtil.IRIS_NORMAL) - .add("paddingTwo", DhBlazeVertexFormatUtil.BYTE_PAD) - .add("paddingThree", DhBlazeVertexFormatUtil.BYTE_PAD) // padding is to make sure the format is a multiple of 4 - .build(); - } + private BlazeDhTerrainRenderer() { } private void tryInit() { @@ -113,6 +101,15 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer "apply/blaze/vert", "apply/blaze/frag" ); + VertexFormat vertexFormat = VertexFormat.builder() + .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) + .add("meta", DhBlazeVertexFormatUtil.META) + .add("vColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) + .add("irisMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) + .add("irisNormal", DhBlazeVertexFormatUtil.IRIS_NORMAL) + .add("paddingTwo", DhBlazeVertexFormatUtil.BYTE_PAD) + .add("paddingThree", DhBlazeVertexFormatUtil.BYTE_PAD) // padding is to make sure the format is a multiple of 4 + .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); { @@ -132,7 +129,7 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer pipelineBuilder.withUniform("vertSharedUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withUniform("fragUniformBlock", UniformType.UNIFORM_BUFFER); - pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + pipelineBuilder.withVertexFormat(vertexFormat, VertexFormat.Mode.TRIANGLES); } // opaque @@ -150,9 +147,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer //endregion - @Override - public int getVertexByteSize() { return this.vertexFormat.getVertexSize(); } - //========// @@ -398,6 +392,12 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer private String getIndexBufferName() { return "distantHorizons:LodIndexBuffer"; } private String getRenderPassName() { return "distantHorizons:McLodRenderer"; } + + @Override + public void runRenderPassSetup(RenderParams renderParams) {} + @Override + public void runRenderPassCleanup(RenderParams renderParams) {} + @Override public void applyToMcTexture() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java index 0620eab58..f9c3f467f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java @@ -11,7 +11,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.common.render.nativeGl.generic.RenderableBoxGroup; +import com.seibel.distanthorizons.core.render.renderer.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.ColorUtil; import org.lwjgl.opengl.GL32; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java index 81e45c6b0..f0d6ae07e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -19,30 +19,58 @@ package com.seibel.distanthorizons.common.render.nativeGl; +import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass; +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePostGL43; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePreGL43; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; import com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat.LodVertexFormat; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; -import com.seibel.distanthorizons.core.util.LodUtil; +import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; +import com.seibel.distanthorizons.core.render.RenderBufferHandler; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; -import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; +import com.seibel.distanthorizons.core.util.objects.SortedArraySet; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; +import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL32; /** * Handles rendering the normal LOD terrain. * @see LodQuadBuilder */ -public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShaderProgram +public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShaderProgram, IDhTerrainRenderer { public final AbstractVertexAttribute vao; @@ -73,6 +101,7 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade //=============// // constructor // //=============// + //region // This will bind AbstractVertexAttribute public DhTerrainShaderProgram() @@ -136,11 +165,14 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade } + //endregion + //=========// // methods // //=========// + //region @Override public void bind() @@ -224,4 +256,537 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade @Override public boolean overrideThisFrame() { return true; } + //endregion + + + + + @Override + public void runRenderPassSetup(RenderParams renderParams) { OpenGlRenderState.INSTANCE.runRenderPassSetup(renderParams); } + + @Override + public void runRenderPassCleanup(RenderParams renderParams) { OpenGlRenderState.INSTANCE.runRenderPassCleanup(renderParams); } + + + @Override + public void render(RenderParams renderEventParam, boolean opaquePass, SortedArraySet bufferContainers, IProfilerWrapper profiler) + { + OpenGlRenderState.INSTANCE.renderLodTerrain(bufferContainers, renderEventParam, opaquePass); + } + @Override + public void applyToMcTexture() + { + } + @Override + public void clearDepth() + { + } + @Override + public void clearColor() + { + } + + + public static class OpenGlRenderState + { + public static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .build(); + + public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .maxCountPerSecond(4) + .build(); + + public static final OpenGlRenderState INSTANCE = new OpenGlRenderState(); + + + private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); + + + // these ID's either what any render is currently using (since only one renderer can be active at a time), or just used previously + private int activeFramebufferId = -1; + private int activeColorTextureId = -1; + private int activeDepthTextureId = -1; + private int textureWidth; + private int textureHeight; + + + private IDhApiShaderProgram lodRenderProgram = null; + public QuadElementBuffer quadIBO = null; + private boolean renderObjectsCreated = false; + + // framebuffer and texture ID's for this renderer + private IDhApiFramebuffer framebuffer; + /** will be null if MC's framebuffer is being used since MC already has a color texture */ + @Nullable + private DhColorTexture nullableColorTexture; + private DHDepthTexture depthTexture; + /** + * If true the {@link OpenGlRenderState#framebuffer} is the same as MC's. + * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. + */ + private boolean usingMcFramebuffer = false; + + + private IDhApiShaderProgram lodShaderProgramThisFrame; + + + // + // + // + + public void runRenderPassSetup(RenderParams renderParams) + { + boolean firstPass = + (renderParams.renderPass == EDhApiRenderPass.OPAQUE + || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); + + if (!this.renderObjectsCreated) + { + boolean setupSuccess = this.createRenderObjects(); + if (!setupSuccess) + { + // shouldn't normally happen, but just in case + return; + } + + this.renderObjectsCreated = true; + } + + + this.setGLState(renderParams, firstPass); + + this.quadIBO.bind(); + renderParams.lightmap.bind(); + + this.lodShaderProgramThisFrame = this.lodRenderProgram; + IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (lodShaderProgramOverride != null && this.lodShaderProgramThisFrame.overrideThisFrame()) + { + this.lodShaderProgramThisFrame = lodShaderProgramOverride; + } + + } + + public void runRenderPassCleanup(RenderParams renderParams) + { + boolean runningDeferredPass = (renderParams.renderPass == EDhApiRenderPass.TRANSPARENT); + + + if (!runningDeferredPass) + { + //===================// + // optifine clean up // + //===================// + + if (this.usingMcFramebuffer) + { + // If MC's framebuffer is being used the depth needs to be cleared to prevent rendering on top of MC. + // This should only happen when Optifine shaders are being used. + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + + + + //=============================// + // Apply to the MC Framebuffer // + //=============================// + + boolean cancelApplyShader = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeApplyShaderRenderEvent.class, renderParams); + if (!cancelApplyShader) + { + //profiler.popPush("LOD Apply"); + + // Copy the LOD framebuffer to Minecraft's framebuffer + DhApplyShader.INSTANCE.render(renderParams.partialTicks); + } + } + + + renderParams.lightmap.unbind(); + this.quadIBO.unbind(); + this.lodShaderProgramThisFrame.unbind(); + } + + + + //=================// + // Setup Functions // + //=================// + //region + + private void setGLState( + DhApiRenderParam renderEventParam, + boolean firstPass) + { + //===================// + // framebuffer setup // + //===================// + + // get the active framebuffer + IDhApiFramebuffer framebuffer = this.framebuffer; + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + if (framebufferOverride != null && framebufferOverride.overrideThisFrame()) + { + framebuffer = framebufferOverride; + } + this.activeFramebufferId = framebuffer.getId(); + framebuffer.bind(); + + + + //==========// + // bindings // + //==========// + + // by default draw everything as triangles + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + + GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); + + GL32.glDisable(GL32.GL_SCISSOR_TEST); + + // Enable depth test and depth mask + GLMC.enableDepthTest(); + GLMC.glDepthFunc(GL32.GL_LESS); + GLMC.enableDepthMask(); + + // This is required for MC versions 1.21.5+ + // due to MC updating the lightmap by changing the viewport size + GL32.glViewport(0, 0, this.textureWidth, this.textureHeight); + + this.lodRenderProgram.bind(); + + + + //==========// + // uniforms // + //==========// + + IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (shaderProgramOverride != null) + { + shaderProgramOverride.fillUniformData(renderEventParam); + } + + this.lodRenderProgram.fillUniformData(renderEventParam); + + + + //===============// + // texture setup // + //===============// + + // resize the textures if needed + if (MC_RENDER.getTargetFramebufferViewportWidth() != this.textureWidth + || MC_RENDER.getTargetFramebufferViewportHeight() != this.textureHeight) + { + // just resizing the textures doesn't work when Optifine is present, + // so recreate the textures with the new size instead + this.createAndBindTextures(); + } + + + // set the active textures + this.activeDepthTextureId = this.depthTexture.getTextureId(); + + if (this.nullableColorTexture != null) + { + this.activeColorTextureId = this.nullableColorTexture.getTextureId(); + } + else + { + // get MC's color texture + this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + } + + + // needs to be fired after all the textures have been created/bound + boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderEventParam); + if (clearTextures) + { + GL32.glClearDepth(1.0); + + float[] clearColorValues = new float[4]; + GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); + GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); + + if (this.usingMcFramebuffer && framebufferOverride == null) + { + // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, + // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues + framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + + + // don't clear the color texture, that removes the sky + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + else if (firstPass) + { + GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + } + } + } + + private boolean createRenderObjects() + { + if (this.renderObjectsCreated) + { + LOGGER.warn("Renderer setup called but it has already completed setup!"); + return false; + } + + // GLProxy should have already been created by this point, but just in case create it now + GLProxy.getInstance(); + + + + LOGGER.info("Setting up renderer"); + this.lodRenderProgram = new DhTerrainShaderProgram(); + + this.quadIBO = new QuadElementBuffer(); + this.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); + + + // create or get the frame buffer + if (AbstractOptifineAccessor.optifinePresent()) + { + // use MC/Optifine's default Framebuffer so shaders won't remove the LODs + int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); + this.framebuffer = new DhFramebuffer(currentFramebufferId); + this.usingMcFramebuffer = true; + } + else + { + // normal use case + this.framebuffer = new DhFramebuffer(); + this.usingMcFramebuffer = false; + } + + // create and bind the necessary textures + this.createAndBindTextures(); + + if(this.framebuffer.getStatus() != GL32.GL_FRAMEBUFFER_COMPLETE) + { + // This generally means something wasn't bound, IE missing either the color or depth texture + LOGGER.warn("Framebuffer ["+this.framebuffer.getId()+"] isn't complete."); + return false; + } + + + + LOGGER.info("Renderer setup complete"); + return true; + } + + @SuppressWarnings( "deprecation" ) // done to ignore DhApiColorDepthTextureCreatedEvent + private void createAndBindTextures() + { + int oldWidth = this.textureWidth; + int oldHeight = this.textureHeight; + this.textureWidth = MC_RENDER.getTargetFramebufferViewportWidth(); + this.textureHeight = MC_RENDER.getTargetFramebufferViewportHeight(); + + DhApiTextureCreatedParam textureCreatedParam = new DhApiTextureCreatedParam( + oldWidth, oldHeight, + this.textureWidth, this.textureHeight + ); + + + // DhApiColorDepthTextureCreatedEvent needs to be kept around since old versions of Iris need it + ApiEventInjector.INSTANCE.fireAllEvents(DhApiColorDepthTextureCreatedEvent.class, new DhApiColorDepthTextureCreatedEvent.EventParam(textureCreatedParam)); + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeColorDepthTextureCreatedEvent.class, textureCreatedParam); + + + // also update the framebuffer override if present + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + + + this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); + this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + if (framebufferOverride != null) + { + framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + } + + + // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound + if (!this.usingMcFramebuffer) + { + this.nullableColorTexture = DhColorTexture.builder() + .setDimensions(this.textureWidth, this.textureHeight) + .setInternalFormat(EDhInternalTextureFormat.RGBA8) + .setPixelType(EDhPixelType.UNSIGNED_BYTE) + .setPixelFormat(EDhPixelFormat.RGBA) + .build(); + + this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + if (framebufferOverride != null) + { + framebufferOverride.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + } + } + else + { + this.nullableColorTexture = null; + } + + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterColorDepthTextureCreatedEvent.class, textureCreatedParam); + } + + //endregion + + + + //===============// + // LOD rendering // + //===============// + //region + + public void renderLodTerrain(SortedArraySet bufferContainers, RenderParams renderEventParam, boolean opaquePass) + { + IDhApiShaderProgram shaderProgram = this.lodShaderProgramThisFrame; + + //=======================// + // debug wireframe setup // + //=======================// + + boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); + if (renderWireframe) + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + GLMC.disableFaceCulling(); + } + else + { + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + if (!opaquePass) + { + GLMC.enableBlend(); + GLMC.enableDepthTest(); + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + } + else + { + GLMC.disableBlend(); + } + + + + + //===========// + // rendering // + //===========// + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam); + + if (IRIS_ACCESSOR != null) + { + // done to fix a bug with Iris where face culling isn't properly set or reverted in the MC state manager + // which causes Sodium to render some water chunks with their normal inverted + // https://github.com/IrisShaders/Iris/issues/2582 + // https://github.com/IrisShaders/Iris/blob/1.21.9/common/src/main/java/net/irisshaders/iris/compat/dh/LodRendererEvents.java#L346 + GLMC.enableFaceCulling(); + } + + + if (bufferContainers != null) + { + for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) + { + LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); + this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, shaderProgram, renderEventParam); + + IVertexBufferWrapper[] vertexBuffers = (opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent); + for (int vboIndex = 0; vboIndex < vertexBuffers.length; vboIndex++) + { + GLVertexBuffer vbo = (GLVertexBuffer) vertexBuffers[vboIndex]; + if (vbo == null) + { + continue; + } + + if (vbo.getVertexCount() == 0) + { + continue; + } + + vbo.bind(); + shaderProgram.bindVertexBuffer(vbo.getId()); + GL32.glDrawElements( + GL32.GL_TRIANGLES, + (int)(vbo.getVertexCount() * 1.5), + this.quadIBO.getType(), 0); + vbo.unbind(); + } + } + } + + + + //=========================// + // debug wireframe cleanup // + //=========================// + + if (renderWireframe) + { + // default back to GL_FILL since all other rendering uses it + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + } + + } + + /** + * the MVM offset is needed so LODs can be rendered anywhere in the MC world + * without running into floating point percision loss. + */ + private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelPos = new Vec3f( + (float) (pos.getX() - camPos.x), + (float) (pos.getY() - camPos.y), + (float) (pos.getZ() - camPos.z)); + + shaderProgram.bind(); + shaderProgram.setModelOffsetPos(modelPos); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + } + + //endregion + + + + //===============// + // API functions // + //===============// + //region + + /** @return -1 if no frame buffer has been bound yet */ + public int getActiveFramebufferId() { return this.activeFramebufferId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveColorTextureId() { return this.activeColorTextureId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveDepthTextureId() { return this.activeDepthTextureId; } + + //endregion + + + } + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java deleted file mode 100644 index 2e1784bba..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/LodRenderer.java +++ /dev/null @@ -1,766 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.render.nativeGl; - -import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; -import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; -import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFadeRenderer; -import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; -import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; -import com.seibel.distanthorizons.core.render.DhApiRenderProxy; -import com.seibel.distanthorizons.core.render.RenderBufferHandler; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog.FogRenderer; -import com.seibel.distanthorizons.core.render.RenderParams; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao.SSAORenderer; -import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; -import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; -import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; -import com.seibel.distanthorizons.core.util.math.Vec3f; -import org.jetbrains.annotations.Nullable; -import org.lwjgl.opengl.GL32; - -/** - * This is where all the magic happens.
- * This is where LODs are draw to the world. - */ -public class LodRenderer -{ - public static final DhLogger LOGGER = new DhLoggerBuilder() - .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) - .build(); - - public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() - .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) - .maxCountPerSecond(4) - .build(); - - private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; - private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); - - public static final LodRenderer INSTANCE = new LodRenderer(); - - - - // these ID's either what any render is currently using (since only one renderer can be active at a time), or just used previously - private int activeFramebufferId = -1; - private int activeColorTextureId = -1; - private int activeDepthTextureId = -1; - private int textureWidth; - private int textureHeight; - - - private IDhApiShaderProgram lodRenderProgram = null; - public QuadElementBuffer quadIBO = null; - private boolean renderObjectsCreated = false; - - // framebuffer and texture ID's for this renderer - private IDhApiFramebuffer framebuffer; - /** will be null if MC's framebuffer is being used since MC already has a color texture */ - @Nullable - private DhColorTexture nullableColorTexture; - private DHDepthTexture depthTexture; - /** - * If true the {@link LodRenderer#framebuffer} is the same as MC's. - * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. - */ - private boolean usingMcFramebuffer = false; - - - - //=============// - // constructor // - //=============// - - private LodRenderer() { } - - - - //===========// - // rendering // - //===========// - //region - - /** - * This will draw both opaque and transparent LODs if - * {@link DhApiRenderProxy#getDeferTransparentRendering()} is false, - * otherwise it will only render opaque LODs. - */ - public void render(RenderParams renderParams, IProfilerWrapper profiler) - { this.renderLodPass(renderParams, profiler, false); } - - /** - * This method is designed for Iris to be able - * to draw water in a deferred rendering context. - * It needs to be updated with any major changes, - * but shouldn't be activated as per deferWaterRendering. - */ - public void renderDeferred(RenderParams renderParams, IProfilerWrapper profiler) - { this.renderLodPass(renderParams, profiler, true); } - - private void renderLodPass(RenderParams renderParams, IProfilerWrapper profiler, boolean runningDeferredPass) - { - //====================// - // validate rendering // - //====================// - - boolean deferTransparentRendering = DhApiRenderProxy.INSTANCE.getDeferTransparentRendering(); - if (runningDeferredPass - && !deferTransparentRendering) - { - return; - } - boolean firstPass = !runningDeferredPass; - - // RenderParams parameter validation should be done before this - if (!renderParams.validationRun) - { - throw new IllegalArgumentException("Render parameters validation"); - } - - RenderBufferHandler renderBufferHandler = renderParams.renderBufferHandler; - IDhGenericRenderer genericRenderer = renderParams.genericRenderer; - ILightMapWrapper lightmap = renderParams.lightmap; - - - - //=================// - // rendering setup // - //=================// - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderSetupEvent.class, renderParams); - profiler.push("LOD GL setup"); - - if (!this.renderObjectsCreated) - { - boolean setupSuccess = this.createRenderObjects(); - if (!setupSuccess) - { - // shouldn't normally happen, but just in case - return; - } - - // only do this once, that way they can still be reverted if desired - if (Config.Client.Advanced.Graphics.overrideVanillaGraphicsSettings.get()) - { - LOGGER.info("Overriding vanilla MC settings to better fit Distant Horizons... This behavior can be disabled in the Distant Horizons config."); - - MC.disableVanillaClouds(); - MC.disableVanillaChunkFadeIn(); - MC.disableFabulousTransparency(); - } - - this.renderObjectsCreated = true; - } - - this.setGLState(renderParams, firstPass); - - lightmap.bind(); - this.quadIBO.bind(); - - if (firstPass) - { - // we only need to sort/cull the LODs during the first frame - profiler.popPush("LOD build render list"); - renderBufferHandler.buildRenderList(renderParams); - } - - IDhApiShaderProgram lodShaderProgram = this.lodRenderProgram; - IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); - if (lodShaderProgramOverride != null && lodShaderProgram.overrideThisFrame()) - { - lodShaderProgram = lodShaderProgramOverride; - } - - - - //===========// - // rendering // - //===========// - - if (!runningDeferredPass) - { - //=========================// - // opaque and non-deferred // - // transparent rendering // - //=========================// - - // opaque LODs - profiler.popPush("LOD Opaque"); - this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ true); - - // custom objects with SSAO - if (Config.Client.Advanced.Graphics.GenericRendering.enableGenericRendering.get()) - { - profiler.popPush("Custom Objects"); - genericRenderer.render(renderParams, profiler, true); - } - - // SSAO - if (Config.Client.Advanced.Graphics.Ssao.enableSsao.get()) - { - profiler.popPush("LOD SSAO"); - SSAORenderer.INSTANCE.render(new Mat4f(renderParams.dhProjectionMatrix), renderParams.partialTicks); - } - - // custom objects without SSAO - if (Config.Client.Advanced.Graphics.GenericRendering.enableGenericRendering.get()) - { - profiler.popPush("Custom Objects"); - genericRenderer.render(renderParams, profiler, false); - } - - // combined pass transparent rendering - if (!deferTransparentRendering - && Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled) - { - profiler.popPush("LOD Transparent"); - this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ false); - } - - // far plane clip fading - if (Config.Client.Advanced.Graphics.Quality.dhFadeFarClipPlane.get() - // the fade shader messes with the GL state in a way Iris doesn't like, - // so skip it if a shader is active - && (IRIS_ACCESSOR == null || !IRIS_ACCESSOR.isShaderPackInUse())) - { - profiler.popPush("Fade Far Clip Fade"); - DhFadeRenderer.INSTANCE.render( - new Mat4f(renderParams.mcModelViewMatrix), new Mat4f(renderParams.mcProjectionMatrix), - renderParams.partialTicks, profiler); - } - - // fog - if (Config.Client.Advanced.Graphics.Fog.enableDhFog.get() - // this is done to fix issues with: underwater fog, blindness effect, etc. - || renderParams.vanillaFogEnabled) - { - profiler.popPush("LOD Fog"); - - Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); - combinedMatrix.multiply(renderParams.dhModelViewMatrix); - - FogRenderer.INSTANCE.render(combinedMatrix, renderParams.partialTicks); - } - - - - //=================// - // debug rendering // - //=================// - - if (Config.Client.Advanced.Debugging.DebugWireframe.enableRendering.get()) - { - profiler.popPush("Debug wireframes"); - - Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); - combinedMatrix.multiply(renderParams.dhModelViewMatrix); - - // Note: this can be very slow if a lot of boxes are being rendered - //DebugRenderer.INSTANCE.render(combinedMatrix); // TODO - } - - - - //===================// - // optifine clean up // - //===================// - - if (this.usingMcFramebuffer) - { - // If MC's framebuffer is being used the depth needs to be cleared to prevent rendering on top of MC. - // This should only happen when Optifine shaders are being used. - GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); - } - - - - //=============================// - // Apply to the MC Framebuffer // - //=============================// - - boolean cancelApplyShader = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeApplyShaderRenderEvent.class, renderParams); - if (!cancelApplyShader) - { - profiler.popPush("LOD Apply"); - - // Copy the LOD framebuffer to Minecraft's framebuffer - DhApplyShader.INSTANCE.render(renderParams.partialTicks); - } - } - else - { - //====================// - // deferred rendering // - //====================// - - if (Config.Client.Advanced.Graphics.Quality.transparency.get().transparencyEnabled) - { - profiler.popPush("LOD Transparent"); - this.renderLodPass(lodShaderProgram, renderBufferHandler, renderParams, /*opaquePass*/ false); - - - if (Config.Client.Advanced.Graphics.Fog.enableDhFog.get() - // this is done to fix issues with: underwater fog, blindness effect, etc. - || renderParams.vanillaFogEnabled) - { - profiler.popPush("LOD Fog"); - - Mat4f combinedMatrix = new Mat4f(renderParams.dhProjectionMatrix); - combinedMatrix.multiply(renderParams.dhModelViewMatrix); - - FogRenderer.INSTANCE.render(combinedMatrix, renderParams.partialTicks); - } - } - } - - - - //================// - // render cleanup // - //================// - - profiler.popPush("LOD cleanup"); - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderCleanupEvent.class, renderParams); - - lightmap.unbind(); - this.quadIBO.unbind(); - lodShaderProgram.unbind(); - - - // end of internal LOD profiling - profiler.pop(); - } - - //endregion - - - - //=================// - // Setup Functions // - //=================// - //region - - private void setGLState( - DhApiRenderParam renderEventParam, - boolean firstPass) - { - //===================// - // framebuffer setup // - //===================// - - // get the active framebuffer - IDhApiFramebuffer framebuffer = this.framebuffer; - IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); - if (framebufferOverride != null && framebufferOverride.overrideThisFrame()) - { - framebuffer = framebufferOverride; - } - this.activeFramebufferId = framebuffer.getId(); - framebuffer.bind(); - - - - //==========// - // bindings // - //==========// - - // by default draw everything as triangles - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - GLMC.enableFaceCulling(); - - GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); - GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); - - GL32.glDisable(GL32.GL_SCISSOR_TEST); - - // Enable depth test and depth mask - GLMC.enableDepthTest(); - GLMC.glDepthFunc(GL32.GL_LESS); - GLMC.enableDepthMask(); - - // This is required for MC versions 1.21.5+ - // due to MC updating the lightmap by changing the viewport size - GL32.glViewport(0, 0, this.textureWidth, this.textureHeight); - - this.lodRenderProgram.bind(); - - - - //==========// - // uniforms // - //==========// - - IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); - if (shaderProgramOverride != null) - { - shaderProgramOverride.fillUniformData(renderEventParam); - } - - this.lodRenderProgram.fillUniformData(renderEventParam); - - - - - //===============// - // texture setup // - //===============// - - // resize the textures if needed - if (MC_RENDER.getTargetFramebufferViewportWidth() != this.textureWidth - || MC_RENDER.getTargetFramebufferViewportHeight() != this.textureHeight) - { - // just resizing the textures doesn't work when Optifine is present, - // so recreate the textures with the new size instead - this.createAndBindTextures(); - } - - - // set the active textures - this.activeDepthTextureId = this.depthTexture.getTextureId(); - - if (this.nullableColorTexture != null) - { - this.activeColorTextureId = this.nullableColorTexture.getTextureId(); - } - else - { - // get MC's color texture - this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); - } - - - // needs to be fired after all the textures have been created/bound - boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderEventParam); - if (clearTextures) - { - GL32.glClearDepth(1.0); - - float[] clearColorValues = new float[4]; - GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); - GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); - - if (this.usingMcFramebuffer && framebufferOverride == null) - { - // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, - // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues - framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - - - // don't clear the color texture, that removes the sky - GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); - } - else if (firstPass) - { - GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); - } - } - - - } - - private boolean createRenderObjects() - { - if (this.renderObjectsCreated) - { - LOGGER.warn("Renderer setup called but it has already completed setup!"); - return false; - } - - // GLProxy should have already been created by this point, but just in case create it now - GLProxy.getInstance(); - - - - LOGGER.info("Setting up renderer"); - this.lodRenderProgram = new DhTerrainShaderProgram(); - - this.quadIBO = new QuadElementBuffer(); - this.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); - - - // create or get the frame buffer - if (AbstractOptifineAccessor.optifinePresent()) - { - // use MC/Optifine's default Framebuffer so shaders won't remove the LODs - int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); - this.framebuffer = new DhFramebuffer(currentFramebufferId); - this.usingMcFramebuffer = true; - } - else - { - // normal use case - this.framebuffer = new DhFramebuffer(); - this.usingMcFramebuffer = false; - } - - // create and bind the necessary textures - this.createAndBindTextures(); - - if(this.framebuffer.getStatus() != GL32.GL_FRAMEBUFFER_COMPLETE) - { - // This generally means something wasn't bound, IE missing either the color or depth texture - LOGGER.warn("Framebuffer ["+this.framebuffer.getId()+"] isn't complete."); - return false; - } - - - - LOGGER.info("Renderer setup complete"); - return true; - } - - @SuppressWarnings( "deprecation" ) // done to ignore DhApiColorDepthTextureCreatedEvent - private void createAndBindTextures() - { - int oldWidth = this.textureWidth; - int oldHeight = this.textureHeight; - this.textureWidth = MC_RENDER.getTargetFramebufferViewportWidth(); - this.textureHeight = MC_RENDER.getTargetFramebufferViewportHeight(); - - DhApiTextureCreatedParam textureCreatedParam = new DhApiTextureCreatedParam( - oldWidth, oldHeight, - this.textureWidth, this.textureHeight - ); - - - // DhApiColorDepthTextureCreatedEvent needs to be kept around since old versions of Iris need it - ApiEventInjector.INSTANCE.fireAllEvents(DhApiColorDepthTextureCreatedEvent.class, new DhApiColorDepthTextureCreatedEvent.EventParam(textureCreatedParam)); - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeColorDepthTextureCreatedEvent.class, textureCreatedParam); - - - // also update the framebuffer override if present - IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); - - - this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); - this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - if (framebufferOverride != null) - { - framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - } - - // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound - if (!this.usingMcFramebuffer) - { - this.nullableColorTexture = DhColorTexture.builder().setDimensions(this.textureWidth, this.textureHeight) - .setInternalFormat(EDhInternalTextureFormat.RGBA8) - .setPixelType(EDhPixelType.UNSIGNED_BYTE) - .setPixelFormat(EDhPixelFormat.RGBA) - .build(); - - this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); - if (framebufferOverride != null) - { - framebufferOverride.addColorAttachment(0, this.nullableColorTexture.getTextureId()); - } - } - else - { - this.nullableColorTexture = null; - } - - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterColorDepthTextureCreatedEvent.class, textureCreatedParam); - } - - //endregion - - - - //===============// - // LOD rendering // - //===============// - //region - - private void renderLodPass(IDhApiShaderProgram shaderProgram, RenderBufferHandler lodBufferHandler, RenderParams renderEventParam, boolean opaquePass) - { - //=======================// - // debug wireframe setup // - //=======================// - - boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); - if (renderWireframe) - { - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); - GLMC.disableFaceCulling(); - } - else - { - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - GLMC.enableFaceCulling(); - } - - if (!opaquePass) - { - GLMC.enableBlend(); - GLMC.enableDepthTest(); - GL32.glBlendEquation(GL32.GL_FUNC_ADD); - GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); - } - else - { - GLMC.disableBlend(); - } - - - - - //===========// - // rendering // - //===========// - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam); - - if (IRIS_ACCESSOR != null) - { - // done to fix a bug with Iris where face culling isn't properly set or reverted in the MC state manager - // which causes Sodium to render some water chunks with their normal inverted - // https://github.com/IrisShaders/Iris/issues/2582 - // https://github.com/IrisShaders/Iris/blob/1.21.9/common/src/main/java/net/irisshaders/iris/compat/dh/LodRendererEvents.java#L346 - GLMC.enableFaceCulling(); - } - - //if (Config.Client.Advanced.Debugging.rendererMode.get() == EDhApiRendererMode.DEFAULT) - //{ - // // Normal LOD rendering - // - // SortedArraySet lodBufferContainer = lodBufferHandler.getColumnRenderBuffers(); - // if (lodBufferContainer != null) - // { - // for (int lodIndex = 0; lodIndex < lodBufferContainer.size(); lodIndex++) - // { - // LodBufferContainer bufferContainer = lodBufferContainer.get(lodIndex); - // this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, shaderProgram, renderEventParam); - // - // GLVertexBuffer[] vbos = opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent; - // for (int vboIndex = 0; vboIndex < vbos.length; vboIndex++) - // { - // GLVertexBuffer vbo = vbos[vboIndex]; - // if (vbo == null) - // { - // continue; - // } - // - // if (vbo.getVertexCount() == 0) - // { - // continue; - // } - // - // vbo.bind(); - // shaderProgram.bindVertexBuffer(vbo.getId()); - // GL32.glDrawElements( - // GL32.GL_TRIANGLES, - // vbo.getVertexCount(), - // this.quadIBO.getType(), 0); - // vbo.unbind(); - // } - // } - // } - //} - //else - { - // basic quad rendering - - IDhTestTriangleRenderer testRenderer = SingletonInjector.INSTANCE.get(IDhTestTriangleRenderer.class); - testRenderer.render(); - - //TestRenderer.INSTANCE.render(); - //McTestRenderer.INSTANCE.render(); - } - - - //=========================// - // debug wireframe cleanup // - //=========================// - - if (renderWireframe) - { - // default back to GL_FILL since all other rendering uses it - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - GLMC.enableFaceCulling(); - } - - } - - /** - * the MVM offset is needed so LODs can be rendered anywhere in the MC world - * without running into floating point percision loss. - */ - private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException - { - Vec3d camPos = renderEventParam.exactCameraPosition; - Vec3f modelPos = new Vec3f( - (float) (pos.getX() - camPos.x), - (float) (pos.getY() - camPos.y), - (float) (pos.getZ() - camPos.z)); - - shaderProgram.bind(); - shaderProgram.setModelOffsetPos(modelPos); - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); - } - - //endregion - - - - //===============// - // API functions // - //===============// - //region - - /** @return -1 if no frame buffer has been bound yet */ - public int getActiveFramebufferId() { return this.activeFramebufferId; } - - /** @return -1 if no texture has been bound yet */ - public int getActiveColorTextureId() { return this.activeColorTextureId; } - - /** @return -1 if no texture has been bound yet */ - public int getActiveDepthTextureId() { return this.activeDepthTextureId; } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java similarity index 92% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java index 7cc016b57..f0fc8af05 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DebugRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java @@ -25,15 +25,11 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.util.math.Mat4f; -import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.util.math.Vec3f; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; import java.nio.ByteBuffer; @@ -43,9 +39,9 @@ import java.nio.ByteOrder; * Handles rendering the wireframe particles * that are used for seeing what the system's doing. */ -public class DebugRenderer extends AbstractDebugWireframeRenderer +public class OpenGlDebugWireframeRenderer extends AbstractDebugWireframeRenderer { - public static DebugRenderer INSTANCE = new DebugRenderer(); + public static OpenGlDebugWireframeRenderer INSTANCE = new OpenGlDebugWireframeRenderer(); public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -102,7 +98,7 @@ public class DebugRenderer extends AbstractDebugWireframeRenderer //=============// //region - private DebugRenderer() { } + private OpenGlDebugWireframeRenderer() { } public void init() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java index a93b03f5a..5b24d3d47 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java @@ -1,5 +1,14 @@ package com.seibel.distanthorizons.common.render.nativeGl; +import com.seibel.distanthorizons.common.render.nativeGl.generic.OpenGlGenericObjectRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.generic.OpenGlGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.OpenGlDummyUniformData; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFarFadeRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.VanillaFadeRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog.DhFogRenderer; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao.DhSSAORenderer; +import com.seibel.distanthorizons.common.render.nativeGl.test.GlTestTriangleRenderer; import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; @@ -10,21 +19,23 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition { - @Override public IDhTerrainRenderer getTerrainRenderer() { return null; } - @Override public IDhSsaoRenderer getSsaoRenderer() { return null; } - @Override public IDhFogRenderer getFogRenderer() { return null; } - @Override public IDhFarFadeRenderer getFarFadeRenderer() { return null; } - @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return null; } + public String getApiName() { return "OpenGL"; } - @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return null; } - @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return null; } + @Override public IDhTerrainRenderer getTerrainRenderer() { return new DhTerrainShaderProgram(); } // TODO not implemented // TODO how to support Iris? + @Override public IDhSsaoRenderer getSsaoRenderer() { return DhSSAORenderer.INSTANCE; } + @Override public IDhFogRenderer getFogRenderer() { return DhFogRenderer.INSTANCE; } + @Override public IDhFarFadeRenderer getFarFadeRenderer() { return DhFarFadeRenderer.INSTANCE; } + @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return OpenGlDebugWireframeRenderer.INSTANCE; } - @Override public IDhGenericRenderer createGenericRenderer() { return null; } + @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return VanillaFadeRenderer.INSTANCE; } + @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return GlTestTriangleRenderer.INSTANCE; } + + @Override public IDhGenericRenderer createGenericRenderer() { return OpenGlGenericObjectRenderer.INSTANCE; } - @Override public IVertexBufferWrapper createVboWrapper(String name) { return null; } - @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return null; } - @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return null; } + @Override public IVertexBufferWrapper createVboWrapper(String name) { return new GLVertexBuffer(); } + @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new OpenGlDummyUniformData(); } + @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new OpenGlGenericObjectVertexContainer(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java deleted file mode 100644 index 7eb2dbb36..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericRenderObjectFactory.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.render.nativeGl.generic; - -import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; -import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderRegister; -import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; -import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.logging.DhLogger; - -import java.util.List; -import java.util.*; - -/** - * Handles creating {@link DhApiRenderableBox}. - * - * @see IDhApiCustomRenderRegister - * @see DhApiRenderableBox - */ -public class GenericRenderObjectFactory implements IDhApiCustomRenderObjectFactory -{ - private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - public static final GenericRenderObjectFactory INSTANCE = new GenericRenderObjectFactory(); - - - - //=============// - // constructor // - //=============// - - private GenericRenderObjectFactory() { } - - - - //================// - // group creation // - //================// - - @Override - public IDhApiRenderableBoxGroup createForSingleBox(String resourceLocation, DhApiRenderableBox box) - { - ArrayList list = new ArrayList<>(); - list.add(box); - return this.createAbsolutePositionedGroup(resourceLocation, list); - } - - @Override - public IDhApiRenderableBoxGroup createRelativePositionedGroup(String resourceLocation, DhApiVec3d originBlockPos, List boxList) - { return new RenderableBoxGroup(resourceLocation, new DhApiVec3d(originBlockPos.x, originBlockPos.y, originBlockPos.z), boxList, true); } - - @Override - public IDhApiRenderableBoxGroup createAbsolutePositionedGroup(String resourceLocation, List boxList) - { return new RenderableBoxGroup(resourceLocation, new DhApiVec3d(0, 0, 0), boxList, false); } - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java index 86c6d7660..30ca56132 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java @@ -31,20 +31,21 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.jar.EPlatform; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.logging.f3.F3Screen; import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.render.renderer.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.render.renderer.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.ISodiumAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhGenericRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; @@ -74,6 +75,9 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); + + public static final OpenGlGenericObjectRenderer INSTANCE = new OpenGlGenericObjectRenderer(); + /** * Can be used to troubleshoot the renderer. * If enabled several debug objects will render around (0,150,0). @@ -86,7 +90,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer private IDhApiGenericObjectShaderProgram instancedShaderProgram; private IDhApiGenericObjectShaderProgram directShaderProgram; - //private GLVertexBuffer boxVertexBuffer; + private GLVertexBuffer boxVertexBuffer; private GLElementBuffer boxIndexBuffer; private boolean instancedRenderingAvailable; @@ -172,7 +176,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer //=============// //region - public OpenGlGenericObjectRenderer() { } + private OpenGlGenericObjectRenderer() { } public void init() { @@ -219,9 +223,9 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer ByteBuffer boxVerticesBuffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); boxVerticesBuffer.rewind(); - //this.boxVertexBuffer = new GLVertexBuffer(false); - //this.boxVertexBuffer.bind(); - //this.boxVertexBuffer.uploadBuffer(boxVerticesBuffer, 8, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES); + this.boxVertexBuffer = new GLVertexBuffer(false); + this.boxVertexBuffer.bind(); + this.boxVertexBuffer.uploadBuffer(boxVerticesBuffer, 8, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES); MemoryUtil.memFree(boxVerticesBuffer); // box vertex indexes @@ -425,7 +429,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer } shaderProgram.bind(renderEventParam); - //shaderProgram.bindVertexBuffer(this.boxVertexBuffer.getId()); + shaderProgram.bindVertexBuffer(this.boxVertexBuffer.getId()); this.boxIndexBuffer.bind(); @@ -474,7 +478,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer boxGroup.tryUpdateInstancedDataAsync(); // skip groups that haven't been uploaded yet - if (boxGroup.vertexBufferContainer.getState() != NativeGlGenericObjectVertexContainer.EState.RENDER) + if (boxGroup.vertexBufferContainer.getState() != OpenGlGenericObjectVertexContainer.EState.RENDER) { continue; } @@ -556,7 +560,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer // Bind instance data // profiler.popPush("binding"); - NativeGlGenericObjectVertexContainer container = (NativeGlGenericObjectVertexContainer)(boxGroup.vertexBufferContainer); + OpenGlGenericObjectVertexContainer container = (OpenGlGenericObjectVertexContainer)(boxGroup.vertexBufferContainer); GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.color); GL32.glEnableVertexAttribArray(1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java similarity index 94% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java index 6d232f05c..c2c6fc29b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/NativeGlGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java @@ -4,6 +4,7 @@ import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.renderer.RenderableBoxGroup; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import org.lwjgl.opengl.GL32; @@ -16,7 +17,7 @@ import java.util.List; * * @see RenderableBoxGroup */ -public class NativeGlGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer +public class OpenGlGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -51,19 +52,6 @@ public class NativeGlGenericObjectVertexContainer implements IDhGenericObjectVer //===========================// //region - /** needs to be done on the render thread */ - public void tryRunRenderThreadSetup() - { - if (this.chunkPos == 0) - { - this.chunkPos = GLMC.glGenBuffers(); - this.subChunkPos = GLMC.glGenBuffers(); - this.scale = GLMC.glGenBuffers(); - this.color = GLMC.glGenBuffers(); - this.material = GLMC.glGenBuffers(); - } - } - public void updateVertexData(List uploadBoxList) { int boxCount = uploadBoxList.size(); @@ -118,11 +106,13 @@ public class NativeGlGenericObjectVertexContainer implements IDhGenericObjectVer this.materialData[i] = box.material; } - this.state = NativeGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD; + this.state = OpenGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD; } public void uploadDataToGpu() { + this.tryCreateBuffers(); + // Upload transformation matrices GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, this.chunkPos); GL32.glBufferData(GL32.GL_ARRAY_BUFFER, this.chunkPosData, GL32.GL_DYNAMIC_DRAW); @@ -141,6 +131,18 @@ public class NativeGlGenericObjectVertexContainer implements IDhGenericObjectVer this.state = EState.RENDER; } + /** needs to be done on the render thread */ + private void tryCreateBuffers() + { + if (this.chunkPos == 0) + { + this.chunkPos = GLMC.glGenBuffers(); + this.subChunkPos = GLMC.glGenBuffers(); + this.scale = GLMC.glGenBuffers(); + this.color = GLMC.glGenBuffers(); + this.material = GLMC.glGenBuffers(); + } + } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java deleted file mode 100644 index c9a7adc99..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/RenderableBoxGroup.java +++ /dev/null @@ -1,361 +0,0 @@ -package com.seibel.distanthorizons.common.render.nativeGl.generic; - -import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; -import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; -import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.logging.DhLogger; -import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; -import com.seibel.distanthorizons.core.util.LodUtil; -import com.seibel.distanthorizons.core.util.threading.PriorityTaskPicker; -import com.seibel.distanthorizons.core.util.threading.ThreadPoolUtil; -import com.seibel.distanthorizons.core.wrapperInterfaces.IWrapperFactory; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; -import org.jetbrains.annotations.Nullable; - -import java.io.Closeable; -import java.util.*; -import java.util.List; -import java.util.concurrent.RejectedExecutionException; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.function.Consumer; -import java.util.function.Predicate; -import java.util.function.UnaryOperator; -import java.util.stream.Stream; - -public class RenderableBoxGroup - extends AbstractList - implements IDhApiRenderableBoxGroup, Closeable -{ - private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final IWrapperFactory WRAPPER_FACTORY = SingletonInjector.INSTANCE.get(IWrapperFactory.class); - - public static final AtomicInteger NEXT_ID_ATOMIC_INT = new AtomicInteger(0); - - - - public final long id; - - public final String resourceLocationNamespace; - public final String resourceLocationPath; - - /** If false the boxes will be positioned relative to the level's origin */ - public final boolean positionBoxesRelativeToGroupOrigin; - - private final List boxList; - /** backup list which allows for uploading the boxes even it the main list is being modified on a different thread. */ - private final List uploadBoxList; - private final DhApiVec3d originBlockPos; - - - public boolean active = true; - public boolean ssaoEnabled = true; - private boolean vertexDataDirty = true; - - public byte skyLight = LodUtil.MAX_MC_LIGHT; - public byte blockLight = LodUtil.MIN_MC_LIGHT; - public DhApiRenderableBoxGroupShading shading = DhApiRenderableBoxGroupShading.getDefaultShaded(); - - @Nullable - public Consumer beforeRenderFunc; - public Consumer afterRenderFunc; - - // instance data - public IDhGenericObjectVertexBufferContainer vertexBufferContainer = WRAPPER_FACTORY.createGenericObjectVboContainer(); - /** double buffering for thread safety and to prevent locking the render thread during update */ - private IDhGenericObjectVertexBufferContainer altVertexBufferContainer = WRAPPER_FACTORY.createGenericObjectVboContainer(); - - - - //=================// - // getters/setters // - //=================// - //region - - @Override - public long getId() { return this.id; } - - @Override - public String getResourceLocationNamespace() { return this.resourceLocationNamespace; } - @Override - public String getResourceLocationPath() { return this.resourceLocationPath; } - - @Override - public void setOriginBlockPos(DhApiVec3d pos) - { - this.originBlockPos.x = pos.x; - this.originBlockPos.y = pos.y; - this.originBlockPos.z = pos.z; - } - - @Override - public DhApiVec3d getOriginBlockPos() { return new DhApiVec3d(this.originBlockPos.x, this.originBlockPos.y, this.originBlockPos.z); } - - - @Override - public void setSkyLight(int skyLight) - { - if (skyLight < LodUtil.MIN_MC_LIGHT - || skyLight > LodUtil.MAX_MC_LIGHT) - { - throw new IllegalArgumentException("Sky light ["+skyLight+"] must be between ["+LodUtil.MIN_MC_LIGHT+"] and ["+LodUtil.MAX_MC_LIGHT+"] (inclusive)."); - } - this.skyLight = (byte)skyLight; - } - @Override - public int getSkyLight() { return this.skyLight; } - - @Override - public void setBlockLight(int blockLight) - { - if (blockLight < LodUtil.MIN_MC_LIGHT - || blockLight > LodUtil.MAX_MC_LIGHT) - { - throw new IllegalArgumentException("Block light ["+blockLight+"] must be between ["+LodUtil.MIN_MC_LIGHT+"] and ["+LodUtil.MAX_MC_LIGHT+"] (inclusive)."); - } - this.blockLight = (byte)blockLight; - } - @Override - public int getBlockLight() { return this.blockLight; } - - @Override - public void setPreRenderFunc(Consumer func) { this.beforeRenderFunc = func; } - - @Override - public void setPostRenderFunc(Consumer func) { this.afterRenderFunc = func; } - - @Override - public void setActive(boolean active) { this.active = active; } - @Override - public boolean isActive() { return this.active; } - - @Override - public void setSsaoEnabled(boolean ssaoEnabled) { this.ssaoEnabled = ssaoEnabled; } - @Override - public boolean isSsaoEnabled() { return this.ssaoEnabled; } - - @Override - public void setShading(DhApiRenderableBoxGroupShading shading) { this.shading = shading; } - @Override - public DhApiRenderableBoxGroupShading getShading() { return this.shading; } - - //endregion - - - - //=============// - // constructor // - //=============// - //region - - public RenderableBoxGroup( - String resourceLocation, - DhApiVec3d originBlockPos, List boxList, - boolean positionBoxesRelativeToGroupOrigin) throws IllegalArgumentException - { - String[] splitResourceLocation = resourceLocation.split(":"); - if (splitResourceLocation.length != 2) - { - throw new IllegalArgumentException("Resource Location must be a string that's separated by a single colon, for example: [DistantHorizons:Beacons], your namespace ["+resourceLocation+"], contains ["+(splitResourceLocation.length-1)+"] colons."); - } - - this.resourceLocationNamespace = splitResourceLocation[0]; - this.resourceLocationPath = splitResourceLocation[1]; - - this.id = NEXT_ID_ATOMIC_INT.getAndIncrement(); - this.boxList = Collections.synchronizedList(new ArrayList<>(boxList)); - this.uploadBoxList = Collections.synchronizedList(new ArrayList<>(boxList)); - - this.originBlockPos = originBlockPos; - this.positionBoxesRelativeToGroupOrigin = positionBoxesRelativeToGroupOrigin; - } - - //endregion - - - - //=================// - // render building // - //=================// - //region - - @Override - public void triggerBoxChange() { this.vertexDataDirty = true; } - - /** - * Does nothing if the vertex data is already up-to-date - * and is meaningless if using direct rendering. - */ - public void tryUpdateInstancedDataAsync() - { - // if the alt container is done, swap it in - if (this.altVertexBufferContainer.getState() == NativeGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD) - { - this.altVertexBufferContainer.uploadDataToGpu(); - - // swap VBO references for rendering - IDhGenericObjectVertexBufferContainer temp = this.vertexBufferContainer; - this.vertexBufferContainer = this.altVertexBufferContainer; - this.altVertexBufferContainer = temp; - - this.vertexDataDirty = false; - - return; - } - - - - // if the vertex data is already up to date, do nothing - if (!this.vertexDataDirty) - { - return; - } - - PriorityTaskPicker.Executor executor = ThreadPoolUtil.getRenderLoadingExecutor(); - if (executor == null || executor.isTerminated()) - { - return; - } - - // if the alternate container is already updating, don't double-queue it - if (this.altVertexBufferContainer.getState() == NativeGlGenericObjectVertexContainer.EState.UPDATING_DATA) - { - return; - } - this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.UPDATING_DATA); - - - - //this.altInstancedVbos.tryRunRenderThreadSetup(); - - // copy over the box list so we can upload without concurrent modification issues - this.uploadBoxList.clear(); - synchronized (this.uploadBoxList) - { - this.uploadBoxList.addAll(this.boxList); - } - - try - { - executor.runTask(() -> - { - try - { - this.altVertexBufferContainer.updateVertexData(this.uploadBoxList); - } - catch (Exception e) - { - LOGGER.error("Unexpected error updating instanced VBO data for: ["+this+"], error: ["+e.getMessage()+"].", e); - this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.ERROR); - } - }); - } - catch (RejectedExecutionException ignore) - { - // the executor was shut down, it should be back up shortly and able to accept new jobs - this.altVertexBufferContainer.setState(NativeGlGenericObjectVertexContainer.EState.NEW); - } - } - - //endregion - - - - //===============// - // render events // - //===============// - //region - - /** - * This is called before every frame, even if {@link this#isActive()} returns false.
- * {@link this#isActive()} can be changed at this point before the object is rendered to the frame. - */ - public void preRender(DhApiRenderParam renderEventParam) - { - if (this.beforeRenderFunc != null) - { - this.beforeRenderFunc.accept(renderEventParam); - } - } - /** - * Called after rendering is completed.
- * Can be used to handle any necessary cleanup. - */ - public void postRender(DhApiRenderParam renderEventParam) - { - if (this.afterRenderFunc != null) - { - this.afterRenderFunc.accept(renderEventParam); - } - } - - //endregion - - - - //================// - // List Overrides // - //================// - //region - - @Override - public boolean add(DhApiRenderableBox box) { return this.boxList.add(box); } - @Override - public DhApiRenderableBox get(int index) { return this.boxList.get(index); } - @Override - public int size() { return this.boxList.size(); } - @Override - public boolean removeIf(Predicate filter) { return this.boxList.removeIf(filter); } - @Override - public boolean remove(Object obj) { return this.boxList.remove(obj); } - @Override - public DhApiRenderableBox remove(int index) { return this.boxList.remove(index); } - @Override - public void replaceAll(UnaryOperator operator) { this.boxList.replaceAll(operator); } - @Override - public void sort(Comparator comparator) { this.boxList.sort(comparator); } - @Override - public void forEach(Consumer action) { this.boxList.forEach(action); } - @Override - public Spliterator spliterator() { return this.boxList.spliterator(); } - @Override - public Stream stream() { return this.boxList.stream(); } - @Override - public Stream parallelStream() { return this.boxList.parallelStream(); } - @Override - public void clear() { this.boxList.clear(); } - - //endregion - - - - //================// - // base overrides // - //================// - //region - - @Override - public String toString() { return "["+this.resourceLocationNamespace+":"+this.resourceLocationPath+"] ID:["+this.id+"], pos:[("+this.originBlockPos.x+", "+this.originBlockPos.y+", "+this.originBlockPos.z+")], size:["+this.size()+"], active:["+this.active+"]"; } - - @Override - public void close() - { - RenderThreadTaskHandler.INSTANCE.queueRunningOnRenderThread(() -> - { - this.vertexBufferContainer.close(); - this.altVertexBufferContainer.close(); - }); - } - - //endregion - - - -} - \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java new file mode 100644 index 000000000..b7e1f5f6b --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java @@ -0,0 +1,13 @@ +package com.seibel.distanthorizons.common.render.nativeGl.glObject; + +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; + +public class OpenGlDummyUniformData implements ILodContainerUniformBufferWrapper +{ + @Override public void createUniformData(LodBufferContainer bufferContainer) { } + @Override public void tryUpload() { } + @Override public void upload() { } + @Override public void close() { } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java index 258b35bf6..c9332b60e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java @@ -75,16 +75,20 @@ public class GLBuffer implements AutoCloseable //==============// // constructors // //==============// + //region static { CLEANUP_THREAD.execute(() -> runPhantomReferenceCleanupLoop()); } public GLBuffer(boolean isBufferStorage) { this.create(isBufferStorage); } + //endregion + //=========// // methods // //=========// + //region // Should be override by subclasses public int getBufferBindingTarget() { return GL32.GL_COPY_READ_BUFFER; } @@ -92,11 +96,14 @@ public class GLBuffer implements AutoCloseable public void bind() { GL32.glBindBuffer(this.getBufferBindingTarget(), this.id); } public void unbind() { GL32.glBindBuffer(this.getBufferBindingTarget(), 0); } + //endregion + //====================// // create and destroy // //====================// + //region protected void create(boolean asBufferStorage) { @@ -168,11 +175,14 @@ public class GLBuffer implements AutoCloseable }); } + //endregion + //==================// // buffer uploading // //==================// + //region /** * Assumes the GL Context is already bound.
@@ -252,11 +262,14 @@ public class GLBuffer implements AutoCloseable GL32.glBufferSubData(this.getBufferBindingTarget(), 0, bb); } + //endregion - //===========// - // overrides // - //===========// + + //================// + // base overrides // + //================// + //region @Override public void close() { this.destroyAsync(); } @@ -268,11 +281,14 @@ public class GLBuffer implements AutoCloseable "[id:" + this.id + ",size:" + this.size + (this.isMapped ? ",MAPPED" : "") + "]"; } + //endregion + //================// // helper methods // //================// + //region /** * Makes sure the buffer exists and is of the correct format @@ -302,11 +318,14 @@ public class GLBuffer implements AutoCloseable } } + //endregion + //================// // static cleanup // //================// + //region private static void runPhantomReferenceCleanupLoop() { @@ -342,4 +361,8 @@ public class GLBuffer implements AutoCloseable } } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java index ad9582239..797331b37 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java @@ -21,6 +21,9 @@ package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; import java.nio.ByteBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import org.lwjgl.opengl.GL32; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; @@ -32,7 +35,7 @@ import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; * @author James Seibel * @version 11-20-2021 */ -public class GLVertexBuffer extends GLBuffer +public class GLVertexBuffer extends GLBuffer implements IVertexBufferWrapper { /** * When uploading to a buffer that is too small, recreate it this many times @@ -40,17 +43,61 @@ public class GLVertexBuffer extends GLBuffer */ protected int vertexCount = 0; public int getVertexCount() { return this.vertexCount; } - // FIXME: This setter is needed for premapping buffer to manually set the vertexCount. Fix this. - public void setVertexCount(int vertexCount) { this.vertexCount = vertexCount; } - public GLVertexBuffer(boolean isBufferStorage) + + //=============// + // constructor // + //=============// + //region + + public GLVertexBuffer() { this(GLProxy.getInstance().getGpuUploadMethod() == EDhApiGpuUploadMethod.BUFFER_STORAGE); } + public GLVertexBuffer(boolean isBufferStorage) { super(isBufferStorage); } + + //endregion + + + + //======================// + // uploading/destroying // + //======================// + //region + + @Override + public int getBufferBindingTarget() { return GL32.GL_ARRAY_BUFFER; } + + @Override + public void upload(ByteBuffer buffer, int vertexCount) { - super(isBufferStorage); + EDhApiGpuUploadMethod uploadMethod = GLProxy.getInstance().getGpuUploadMethod(); + int maxBufferSize = LodQuadBuilder.getMaxBufferByteSize(); + this.uploadBuffer(buffer, vertexCount, uploadMethod, maxBufferSize); + } + + /** + * bufferSize is the number of shared verticies.
+ * This number will be higher when actually rendered since each box's face needs 2 triangles + * with 2 shared verticies. + */ + public void uploadBuffer(ByteBuffer byteBuffer, int vertexCount, EDhApiGpuUploadMethod uploadMethod, int maxExpansionSize) + { + if (vertexCount < 0) + { + throw new IllegalArgumentException("vertexCount is negative!"); + } + + // If size is zero, just ignore it. + if (byteBuffer.limit() - byteBuffer.position() != 0) + { + boolean useBuffStorage = uploadMethod.useBufferStorage; + super.uploadBuffer(byteBuffer, uploadMethod, maxExpansionSize, useBuffStorage ? 0 : GL32.GL_STATIC_DRAW); + } + this.vertexCount = vertexCount; } - + @Override + public void close() { this.destroyAsync(); } @Override public void destroyAsync() { @@ -58,31 +105,8 @@ public class GLVertexBuffer extends GLBuffer this.vertexCount = 0; } - @Override - public int getBufferBindingTarget() { return GL32.GL_ARRAY_BUFFER; } + //endregion + - /** - * bufferSize is the number of shared verticies.
- * This number will be higher when actually rendered since each box's face needs 2 triangles - * with 2 shared verticies. - */ - public void uploadBuffer(ByteBuffer byteBuffer, int bufferSize, EDhApiGpuUploadMethod uploadMethod, int maxExpensionSize) - { - if (bufferSize < 0) - { - throw new IllegalArgumentException("VertCount is negative!"); - } - - // If size is zero, just ignore it. - if (byteBuffer.limit() - byteBuffer.position() != 0) - { - boolean useBuffStorage = uploadMethod.useBufferStorage; - super.uploadBuffer(byteBuffer, uploadMethod, maxExpensionSize, useBuffStorage ? 0 : GL32.GL_STATIC_DRAW); - } - - // /4 to get the number of cubes - // *6 to get the number of verticies (2 triangles, 3 verticies each) - this.vertexCount = (bufferSize / 4) * 6; - } } \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java index 2c6bc961b..ff1369a46 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java @@ -11,9 +11,6 @@ public class DhFramebuffer implements IDhApiFramebuffer private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; private final Int2IntMap attachments; - private final int maxDrawBuffers; - private final int maxColorAttachments; - private boolean hasDepthAttachment; private int id; @@ -27,9 +24,6 @@ public class DhFramebuffer implements IDhApiFramebuffer this.id = GL32.glGenFramebuffers(); this.attachments = new Int2IntArrayMap(); - this.maxDrawBuffers = GL32.glGetInteger(GL32.GL_MAX_DRAW_BUFFERS); - this.maxColorAttachments = GL32.glGetInteger(GL32.GL_MAX_COLOR_ATTACHMENTS); - this.hasDepthAttachment = false; } /** For internal use by Iris, do not remove. */ @@ -38,9 +32,6 @@ public class DhFramebuffer implements IDhApiFramebuffer this.id = id; this.attachments = new Int2IntArrayMap(); - this.maxDrawBuffers = GL32.glGetInteger(GL32.GL_MAX_DRAW_BUFFERS); - this.maxColorAttachments = GL32.glGetInteger(GL32.GL_MAX_COLOR_ATTACHMENTS); - this.hasDepthAttachment = false; } @@ -56,8 +47,6 @@ public class DhFramebuffer implements IDhApiFramebuffer int depthAttachment = isCombinedStencil ? GL32.GL_DEPTH_STENCIL_ATTACHMENT : GL32.GL_DEPTH_ATTACHMENT; GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, depthAttachment, GL32.GL_TEXTURE_2D, textureId, 0); - - this.hasDepthAttachment = true; } @Override @@ -69,46 +58,6 @@ public class DhFramebuffer implements IDhApiFramebuffer this.attachments.put(textureIndex, textureId); } - public void noDrawBuffers() - { - this.bind(); - GL32.glDrawBuffers(new int[]{GL32.GL_NONE}); - } - - public void drawBuffers(int[] buffers) - { - int[] glBuffers = new int[buffers.length]; - int index = 0; - - if (buffers.length > this.maxDrawBuffers) - { - throw new IllegalArgumentException("Cannot write to more than " + this.maxDrawBuffers + " draw buffers on this GPU"); - } - - for (int buffer : buffers) - { - if (buffer >= this.maxColorAttachments) - { - throw new IllegalArgumentException("Only " + this.maxColorAttachments + " color attachments are supported on this GPU, but an attempt was made to write to a color attachment with index " + buffer); - } - - glBuffers[index++] = GL32.GL_COLOR_ATTACHMENT0 + buffer; - } - - this.bind(); - GL32.glDrawBuffers(new int[]{GL32.GL_NONE}); - } - - public void readBuffer(int buffer) - { - this.bind(); - GL32.glReadBuffer(GL32.GL_COLOR_ATTACHMENT0 + buffer); - } - - public int getColorAttachment(int index) { return this.attachments.get(index); } - - public boolean hasDepthAttachment() { return this.hasDepthAttachment; } - @Override public void bind() { @@ -119,10 +68,6 @@ public class DhFramebuffer implements IDhApiFramebuffer GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, this.id); } - public void bindAsReadBuffer() { GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, this.id); } - - public void bindAsDrawBuffer() { GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, this.id); } - @Override public void destroy() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java index 8405d39e7..f42223b94 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java @@ -19,6 +19,8 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing; +import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; import org.lwjgl.opengl.GL32; @@ -34,22 +36,26 @@ public class ScreenQuad { public static ScreenQuad INSTANCE = new ScreenQuad(); - private static final float[] box_vertices = { + private static final float[] BOX_VERTICES = { -1, -1, 1, -1, 1, 1, + -1, -1, 1, 1, -1, 1, }; + private GLVertexBuffer boxBuffer; private AbstractVertexAttribute va; private boolean init = false; + //=============// // constructor // //=============// + //region private ScreenQuad() { } @@ -68,29 +74,43 @@ public class ScreenQuad // Framebuffer this.createBuffer(); } + private void createBuffer() + { + ByteBuffer buffer = MemoryUtil.memAlloc(BOX_VERTICES.length * Float.BYTES); + buffer.asFloatBuffer().put(BOX_VERTICES); + buffer.rewind(); + + this.boxBuffer = new GLVertexBuffer(false); + this.boxBuffer.bind(); + this.boxBuffer.uploadBuffer(buffer, BOX_VERTICES.length, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES); + MemoryUtil.memFree(buffer); + } + + //endregion + + + + //===========// + // rendering // + //===========// + //region public void render() { this.init(); - //this.boxBuffer.bind(); + this.boxBuffer.bind(); this.va.bind(); - //this.va.bindBufferToAllBindingPoints(this.boxBuffer.getId()); + this.va.bindBufferToAllBindingPoints(this.boxBuffer.getId()); + + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 6); } - private void createBuffer() - { - ByteBuffer buffer = MemoryUtil.memAlloc(box_vertices.length * Float.BYTES); - buffer.asFloatBuffer().put(box_vertices); - buffer.rewind(); - - //this.boxBuffer = new GLVertexBuffer(false); - //this.boxBuffer.bind(); - //this.boxBuffer.uploadBuffer(buffer, box_vertices.length, EDhApiGpuUploadMethod.DATA, box_vertices.length * Float.BYTES); - MemoryUtil.memFree(buffer); - } + //endregion + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java index 718e6a3c9..542780d7c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java @@ -19,19 +19,18 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.logging.DhLogger; import org.lwjgl.opengl.GL32; /** - * Copies {@link BlazeLodRenderer}'s currently active color and depth texture to Minecraft's framebuffer. + * Copies {@link com.seibel.distanthorizons.core.render.renderer.LodRenderer}'s currently active color and depth texture to Minecraft's framebuffer. */ public class DhApplyShader extends AbstractShaderRenderer { @@ -118,11 +117,11 @@ public class DhApplyShader extends AbstractShaderRenderer //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); // Copy to MC's framebuffer @@ -142,7 +141,7 @@ public class DhApplyShader extends AbstractShaderRenderer return; } - int dhFrameBufferId = BlazeLodRenderer.INSTANCE.getActiveFramebufferId(); + int dhFrameBufferId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId(); if (dhFrameBufferId == -1) { return; @@ -162,20 +161,15 @@ public class DhApplyShader extends AbstractShaderRenderer // blending isn't needed, we're just directly merging the MC and DH textures // Note: this prevents the sun/moon and stars from rendering through transparent LODs, - // however this also fixes + // but it also resolves some other issues, so it's likely not an issue GLMC.disableBlend(); - // old blending logic in case it's ever needed: - //GLMC.enableBlend(); - //GL32.glBlendEquation(GL32.GL_FUNC_ADD); - //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); - GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java similarity index 88% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java index 366755515..d93e33dd0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/FadeApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java @@ -21,11 +21,8 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.VanillaFadeRenderer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; /** @@ -35,9 +32,9 @@ import org.lwjgl.opengl.GL32; * {@link VanillaFadeRenderer} - Parent to this shader.
* {@link VanillaFadeShader} - draws the Fade texture.
*/ -public class FadeApplyShader extends AbstractShaderRenderer +public class DhFarFadeApplyShader extends AbstractShaderRenderer { - public static FadeApplyShader INSTANCE = new FadeApplyShader(); + public static DhFarFadeApplyShader INSTANCE = new DhFarFadeApplyShader(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java similarity index 71% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java index 222f26fe9..785ebd9fc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java @@ -19,29 +19,29 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; -import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhFarFadeRenderer; import org.lwjgl.opengl.GL32; import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; /** - * Handles fading MC and DH together via {@link DhFadeShader} and {@link FadeApplyShader}.

+ * Handles fading MC and DH together via {@link DhFarFadeShader} and {@link DhFarFadeApplyShader}.

* - * {@link DhFadeShader} - draws the Fade to a texture.
- * {@link FadeApplyShader} - draws the Fade texture to DH's framebuffer.
+ * {@link DhFarFadeShader} - draws the Fade to a texture.
+ * {@link DhFarFadeApplyShader} - draws the Fade texture to DH's framebuffer.
*/ -public class DhFadeRenderer +public class DhFarFadeRenderer implements IDhFarFadeRenderer { - public static DhFadeRenderer INSTANCE = new DhFadeRenderer(); + public static DhFarFadeRenderer INSTANCE = new DhFarFadeRenderer(); private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); @@ -61,16 +61,17 @@ public class DhFadeRenderer //=============// // constructor // //=============// + //region - private DhFadeRenderer() { } + private DhFarFadeRenderer() { } public void init() { if (this.init) return; this.init = true; - DhFadeShader.INSTANCE.init(); - FadeApplyShader.INSTANCE.init(); + DhFarFadeShader.INSTANCE.init(); + DhFarFadeApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -107,17 +108,21 @@ public class DhFadeRenderer } + //endregion + //========// // render // //========// + //region - public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, float partialTicks, IProfilerWrapper profiler) + @Override + public void render(RenderParams renderParams) { try { - profiler.push("Fade Generate"); + //profiler.push("Fade Generate"); this.init(); @@ -132,19 +137,16 @@ public class DhFadeRenderer } - DhFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; - DhFadeShader.INSTANCE.setProjectionMatrix(mcModelViewMatrix, mcProjectionMatrix); - DhFadeShader.INSTANCE.render(partialTicks); + DhFarFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; + DhFarFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); + DhFarFadeShader.INSTANCE.render(0.0f); - // restored so we can write the fade texture to the main frame buffer - //mcState.restore(); + //profiler.popPush("Fade Apply"); - profiler.popPush("Fade Apply"); - - FadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; - FadeApplyShader.INSTANCE.readFramebuffer = DhFadeShader.INSTANCE.frameBuffer; - FadeApplyShader.INSTANCE.drawFramebuffer = BlazeLodRenderer.INSTANCE.getActiveFramebufferId(); - FadeApplyShader.INSTANCE.render(partialTicks); + DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; + DhFarFadeApplyShader.INSTANCE.drawFramebuffer = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId(); + DhFarFadeApplyShader.INSTANCE.render(0.0f); } catch (Exception e) { @@ -152,10 +154,12 @@ public class DhFadeRenderer } finally { - profiler.pop(); + //profiler.pop(); } } + //emdregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java similarity index 89% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java index e8037a8d3..941367df1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java @@ -19,20 +19,21 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -public class DhFadeShader extends AbstractShaderRenderer +public class DhFarFadeShader extends AbstractShaderRenderer { - public static DhFadeShader INSTANCE = new DhFadeShader(); + public static DhFarFadeShader INSTANCE = new DhFarFadeShader(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -61,7 +62,7 @@ public class DhFadeShader extends AbstractShaderRenderer // constructor // //=============// - public DhFadeShader() { } + public DhFarFadeShader() { } @Override public void onInit() @@ -108,7 +109,7 @@ public class DhFadeShader extends AbstractShaderRenderer } - public void setProjectionMatrix(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + public void setProjectionMatrix(DhApiMat4f mcModelViewMatrix, DhApiMat4f mcProjectionMatrix) { Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); @@ -127,8 +128,8 @@ public class DhFadeShader extends AbstractShaderRenderer @Override protected void onRender() { - int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = BlazeLodRenderer.INSTANCE.getActiveColorTextureId(); + int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java similarity index 84% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java index 70a777c2e..592148d97 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/VanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java @@ -17,20 +17,18 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing; +package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFadeShader; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.FadeApplyShader; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.VanillaFadeShader; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhVanillaFadeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import org.lwjgl.opengl.GL32; @@ -38,12 +36,12 @@ import org.lwjgl.opengl.GL32; import java.nio.ByteBuffer; /** - * Handles fading MC and DH together via {@link VanillaFadeShader} and {@link FadeApplyShader}.

+ * Handles fading MC and DH together via {@link VanillaFadeShader} and {@link DhFarFadeApplyShader}.

* * {@link VanillaFadeShader} - draws the Fade to a texture.
- * {@link FadeApplyShader} - draws the Fade texture to MC's FrameBuffer.
+ * {@link DhFarFadeApplyShader} - draws the Fade texture to MC's FrameBuffer.
*/ -public class VanillaFadeRenderer +public class VanillaFadeRenderer implements IDhVanillaFadeRenderer { public static VanillaFadeRenderer INSTANCE = new VanillaFadeRenderer(); @@ -67,6 +65,7 @@ public class VanillaFadeRenderer //=============// // constructor // //=============// + //region private VanillaFadeRenderer() { } @@ -76,7 +75,7 @@ public class VanillaFadeRenderer this.init = true; VanillaFadeShader.INSTANCE.init(); - FadeApplyShader.INSTANCE.init(); + DhFarFadeApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -114,15 +113,19 @@ public class VanillaFadeRenderer } } + //endregion + //========// // render // //========// + //region + @Override public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) { - int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); + int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); if (depthTextureId == -1) { // the renderer hasn't been set up yet @@ -165,10 +168,10 @@ public class VanillaFadeRenderer { profiler.popPush("Vanilla Fade Apply"); - FadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; - FadeApplyShader.INSTANCE.readFramebuffer = DhFadeShader.INSTANCE.frameBuffer; - FadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); - FadeApplyShader.INSTANCE.render(0); + DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; + DhFarFadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); + DhFarFadeApplyShader.INSTANCE.render(0); } profiler.pop(); @@ -179,10 +182,23 @@ public class VanillaFadeRenderer } } + //endregion + + + + //================// + // base overrides // + //================// + //region + public void free() { VanillaFadeShader.INSTANCE.free(); - FadeApplyShader.INSTANCE.free(); + DhFarFadeApplyShader.INSTANCE.free(); } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java index 48f625d57..6bc666ac3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java @@ -19,19 +19,19 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -public class VanillaFadeShader extends AbstractShaderRenderer +public class VanillaFadeShader extends AbstractShaderRenderer { public static VanillaFadeShader INSTANCE = new VanillaFadeShader(); @@ -67,6 +67,7 @@ public class VanillaFadeShader extends AbstractShaderRenderer //=============// // constructor // //=============// + //region public VanillaFadeShader() { } @@ -99,11 +100,14 @@ public class VanillaFadeShader extends AbstractShaderRenderer } + //endregion + //=============// // render prep // //=============// + //region @Override protected void onApplyUniforms(float partialTicks) @@ -148,17 +152,20 @@ public class VanillaFadeShader extends AbstractShaderRenderer } public void setLevelMaxHeight(int levelMaxHeight) { this.levelMaxHeight = levelMaxHeight; } + //endregion + //========// // render // //========// + //region @Override protected void onRender() { - int depthTextureId = BlazeLodRenderer.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = BlazeLodRenderer.INSTANCE.getActiveColorTextureId(); + int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) @@ -195,4 +202,8 @@ public class VanillaFadeShader extends AbstractShaderRenderer ScreenQuad.INSTANCE.render(); } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java similarity index 89% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java index 04079baf7..24ad5d80c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java @@ -19,11 +19,12 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhFogRenderer; import org.lwjgl.opengl.GL32; import org.lwjgl.opengl.GL43C; @@ -35,9 +36,9 @@ import java.nio.ByteBuffer; * {@link FogShader} - draws the Fog to a texture.
* {@link FogApplyShader} - draws the Fog texture to DH's FrameBuffer.
*/ -public class FogRenderer +public class DhFogRenderer implements IDhFogRenderer { - public static FogRenderer INSTANCE = new FogRenderer(); + public static DhFogRenderer INSTANCE = new DhFogRenderer(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -57,7 +58,7 @@ public class FogRenderer // constructor // //=============// - private FogRenderer() { } + private DhFogRenderer() { } public void init() { @@ -104,8 +105,10 @@ public class FogRenderer //========// // render // //========// + //region - public void render(Mat4f modelViewProjectionMatrix, float partialTicks) + @Override + public void render(DhApiMat4f modelViewProjectionMatrix, float partialTicks) { // GLState needed in MC 1.16.5 probably due to MC not manually setting each GL state they need before the next rendering step try (GLState state = new GLState()) @@ -131,10 +134,23 @@ public class FogRenderer } } + //endregion + + + + //================// + // base overrides // + //================// + //region + public void free() { FogShader.INSTANCE.free(); FogApplyShader.INSTANCE.free(); } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java index 58fca26d3..6fa439e6d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java @@ -19,11 +19,10 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import org.lwjgl.opengl.GL32; @@ -31,7 +30,7 @@ import org.lwjgl.opengl.GL32; * Draws the Fog texture onto DH's FrameBuffer.

* * See Also:
- * {@link FogRenderer} - Parent to this shader.
+ * {@link DhFogRenderer} - Parent to this shader.
* {@link FogShader} - draws the Fog texture.
*/ public class FogApplyShader extends AbstractShaderRenderer @@ -82,7 +81,7 @@ public class FogApplyShader extends AbstractShaderRenderer GL32.glUniform1i(this.colorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.depthTextureUniform, 1); } @@ -108,7 +107,7 @@ public class FogApplyShader extends AbstractShaderRenderer // apply the rendered Fog to DH's framebuffer GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, FogShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, BlazeLodRenderer.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId()); ScreenQuad.INSTANCE.render(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java index 0ac0b00ab..289a59c22 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java @@ -22,12 +22,13 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; @@ -244,7 +245,7 @@ public class FogShader extends AbstractShaderRenderer return fogColor; } - public void setProjectionMatrix(Mat4f modelViewProjectionMatrix) + public void setProjectionMatrix(DhApiMat4f modelViewProjectionMatrix) { this.inverseMvmProjMatrix = new Mat4f(modelViewProjectionMatrix); this.inverseMvmProjMatrix.invert(); @@ -265,7 +266,7 @@ public class FogShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.uDepthMap, 0); // this is necessary for MC 1.16 (IE Legacy OpenGL) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java similarity index 86% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java index 88d3172c7..5110cf894 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAORenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java @@ -19,11 +19,12 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhSsaoRenderer; import org.lwjgl.opengl.GL32; import org.lwjgl.opengl.GL43C; @@ -35,9 +36,9 @@ import java.nio.ByteBuffer; * {@link SSAOShader} - draws the SSAO to a texture.
* {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
*/ -public class SSAORenderer +public class DhSSAORenderer implements IDhSsaoRenderer { - public static SSAORenderer INSTANCE = new SSAORenderer(); + public static DhSSAORenderer INSTANCE = new DhSSAORenderer(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -57,7 +58,7 @@ public class SSAORenderer // constructor // //=============// - private SSAORenderer() { } + private DhSSAORenderer() { } public void init() { @@ -105,8 +106,9 @@ public class SSAORenderer //========// // render // //========// + //region - public void render(Mat4f projectionMatrix, float partialTicks) + public void render(DhApiMat4f dhProjectionMatrix) { try(GLState state = new GLState()) { @@ -123,18 +125,31 @@ public class SSAORenderer } SSAOShader.INSTANCE.frameBuffer = this.ssaoFramebuffer; - SSAOShader.INSTANCE.setProjectionMatrix(projectionMatrix); - SSAOShader.INSTANCE.render(partialTicks); + SSAOShader.INSTANCE.setProjectionMatrix(dhProjectionMatrix); + SSAOShader.INSTANCE.render(0.0f); SSAOApplyShader.INSTANCE.ssaoTexture = this.ssaoTexture; - SSAOApplyShader.INSTANCE.render(partialTicks); + SSAOApplyShader.INSTANCE.render(0.0f); } } + //endregion + + + + //================// + // base overrides // + //================// + //region + public void free() { SSAOShader.INSTANCE.free(); SSAOApplyShader.INSTANCE.free(); } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java index 0da10356a..86569beeb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java @@ -19,10 +19,10 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.util.RenderUtil; import org.lwjgl.opengl.GL32; @@ -31,7 +31,7 @@ import org.lwjgl.opengl.GL32; * Draws the SSAO texture onto DH's FrameBuffer.

* * See Also:
- * {@link SSAORenderer} - Parent to this shader.
+ * {@link DhSSAORenderer} - Parent to this shader.
* {@link SSAOShader} - draws the SSAO texture.
*/ public class SSAOApplyShader extends AbstractShaderRenderer @@ -85,7 +85,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer protected void onApplyUniforms(float partialTicks) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); @@ -134,7 +134,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer // apply the rendered SSAO to the LODs GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, SSAOShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, BlazeLodRenderer.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId()); ScreenQuad.INSTANCE.render(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java index 36e285d24..bcf66f88f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java @@ -19,10 +19,11 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.render.renderer.BlazeLodRenderer; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; import com.seibel.distanthorizons.core.util.math.Mat4f; import org.lwjgl.opengl.GL32; @@ -31,7 +32,7 @@ import org.lwjgl.opengl.GL32; * Draws the SSAO to a texture.

* * See Also:
- * {@link SSAORenderer} - Parent to this shader.
+ * {@link DhSSAORenderer} - Parent to this shader.
* {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
*/ public class SSAOShader extends AbstractShaderRenderer @@ -91,9 +92,9 @@ public class SSAOShader extends AbstractShaderRenderer // render prep // //=============// - public void setProjectionMatrix(Mat4f projectionMatrix) + public void setProjectionMatrix(DhApiMat4f projectionMatrix) { - this.projection = projectionMatrix; + this.projection = new Mat4f(projectionMatrix); this.invertedProjection = new Mat4f(projectionMatrix); this.invertedProjection.invert(); @@ -132,7 +133,7 @@ public class SSAOShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(BlazeLodRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); ScreenQuad.INSTANCE.render(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java similarity index 88% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java index 8daab7b83..9e6d5368c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.test; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -30,6 +31,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribut import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; import org.lwjgl.opengl.GL32; import java.nio.ByteBuffer; @@ -40,14 +42,14 @@ import java.nio.ByteOrder; * to the center of the screen to confirm DH's * apply shader is running correctly */ -public class GlTestRenderer +public class GlTestTriangleRenderer implements IDhTestTriangleRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; - public static final GlTestRenderer INSTANCE = new GlTestRenderer(); + public static final GlTestTriangleRenderer INSTANCE = new GlTestTriangleRenderer(); // Render a square with uv color private static final float[] VERTICES = @@ -72,7 +74,7 @@ public class GlTestRenderer //=============// //region - private GlTestRenderer() { } + private GlTestTriangleRenderer() { } public void init() { @@ -108,7 +110,7 @@ public class GlTestRenderer this.vbo = new GLVertexBuffer(false); this.vbo.bind(); - this.vbo.uploadBuffer(buffer, 4, EDhApiGpuUploadMethod.DATA, VERTICES.length * Float.BYTES); + this.vbo.uploadBuffer(buffer, 3, EDhApiGpuUploadMethod.DATA, VERTICES.length * Float.BYTES); } //endregion @@ -130,8 +132,7 @@ public class GlTestRenderer this.vbo.bind(); this.va.bindBufferToAllBindingPoints(this.vbo.getId()); - // Render the square - GL32.glDrawArrays(GL32.GL_TRIANGLE_FAN, 0, 4); + GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 3); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index f6c1bfdd6..15163d609 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -23,12 +23,12 @@ import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; import com.seibel.distanthorizons.common.render.blaze.BlazeDhRenderApiDefinition; import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhRenderApiDefinition; -import com.seibel.distanthorizons.common.render.nativeGl.generic.GenericRenderObjectFactory; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.render.renderer.GenericRenderObjectFactory; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; import com.seibel.distanthorizons.common.wrappers.gui.LangWrapper; import com.seibel.distanthorizons.common.wrappers.level.KeyedClientLevelManager; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftServerWrapper; -import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.level.IKeyedClientLevelManager; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; diff --git a/coreSubProjects b/coreSubProjects index 559bad567..1b0f93db0 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 559bad5676d492b832fa6958e3c1ca57df42f1c8 +Subproject commit 1b0f93db07eb071eb74294a58e6e4e6f385acf7d diff --git a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java index cd87569d1..8329d4148 100644 --- a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java +++ b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinLightTexture.java @@ -93,9 +93,14 @@ public class MixinLightTexture this.renderWrapper.updateLightmap(this.lightPixels, clientLevel); #elif MC_VER < MC_1_21_5 this.renderWrapper.setLightmapId(this.target.getColorTextureId(), clientLevel); + #elif MC_VER <= MC_1_21_10 + GlTexture glTexture = (GlTexture) this.texture; + this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); #else - //GlTexture glTexture = (GlTexture) this.texture; - //this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + // both options are available since the renderer can be changed to either Blaze3D or OpenGL + GlTexture glTexture = (GlTexture) this.texture; + this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + this.renderWrapper.setLightmapGpuTexture(this.texture, clientLevel); #endif } diff --git a/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java b/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java index ab6b806ef..417b030c1 100644 --- a/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java +++ b/neoforge/src/main/java/com/seibel/distanthorizons/neoforge/mixins/client/MixinLightTexture.java @@ -85,9 +85,14 @@ public class MixinLightTexture #elif MC_VER < MC_1_21_9 GlTexture glTexture = (GlTexture) this.texture; renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + #elif MC_VER <= MC_1_21_10 + GlTexture glTexture = (GlTexture) this.texture; + this.renderWrapper.setLightmapId(glTexture.glId(), clientLevel); #else - //int id = NeoforgeTextureUnwrapper.getGlTextureIdFromGpuTexture(this.texture); - //renderWrapper.setLightmapId(id, clientLevel); + // both options are available since the renderer can be changed to either Blaze3D or OpenGL + GlTexture glTexture = (GlTexture) this.texture; + renderWrapper.setLightmapId(glTexture.glId(), clientLevel); + renderWrapper.setLightmapGpuTexture(this.texture, clientLevel); #endif } From 88f945bf22f1c032cb730db7441452f82113b4a9 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 14:52:09 -0500 Subject: [PATCH 52/72] separate out some rendering logic --- .../blaze/BlazeDebugWireframeRenderer.java | 8 +- .../blaze/BlazeDhGenericObjectRenderer.java | 8 +- .../render/blaze/BlazeDhMetaRenderer.java | 88 +++ .../blaze/BlazeDhRenderApiDefinition.java | 2 + .../render/blaze/BlazeDhTerrainRenderer.java | 37 +- .../BlazeDhFarFadeRenderer.java | 11 +- .../postProcessing/BlazeDhFogRenderer.java | 7 +- .../postProcessing/BlazeDhSsaoRenderer.java | 9 +- .../BlazeVanillaFadeRenderer.java | 9 +- .../nativeGl/DhTerrainShaderProgram.java | 623 ++++-------------- .../render/nativeGl/OpenGlDhMetaRenderer.java | 448 +++++++++++++ .../nativeGl/OpenGlDhRenderApiDefinition.java | 3 +- .../postProcessing/apply/DhApplyShader.java | 11 +- .../fade/DhFarFadeRenderer.java | 3 +- .../postProcessing/fade/DhFarFadeShader.java | 5 +- .../fade/VanillaFadeRenderer.java | 3 +- .../fade/VanillaFadeShader.java | 5 +- .../postProcessing/fog/FogApplyShader.java | 5 +- .../postProcessing/fog/FogShader.java | 3 +- .../postProcessing/ssao/SSAOApplyShader.java | 5 +- .../postProcessing/ssao/SSAOShader.java | 3 +- .../nativeGl/test/GlTestTriangleRenderer.java | 2 + coreSubProjects | 2 +- 23 files changed, 713 insertions(+), 587 deletions(-) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index ea99296f2..286c7f818 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -224,8 +224,8 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer { this.init(); - if (BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -295,9 +295,9 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer try (RenderPass renderPass = commandEncoder.createRenderPass( this::getRenderPassName, - BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, + BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { // Bind instance data // diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index 56547fba9..c8183fa58 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -346,8 +346,8 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer //#endregion - if (BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty()) { return; } @@ -497,9 +497,9 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer try (RenderPass renderPass = COMMAND_ENCODER.createRenderPass( this::getRenderPassName, - BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, + BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureView, /*optionalClearColorAsInt*/ OptionalInt.empty(), - BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, + BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { this.renderBoxGroupInstanced(renderPass, renderEventParam, boxGroup, camPos, profiler); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java new file mode 100644 index 000000000..4c3f1ab86 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java @@ -0,0 +1,88 @@ +package com.seibel.distanthorizons.common.render.blaze; + +import com.mojang.blaze3d.textures.GpuTexture; +import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; +import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.util.ColorUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhMetaRenderer; +import net.minecraft.client.Minecraft; + +public class BlazeDhMetaRenderer implements IDhMetaRenderer +{ + public static final BlazeDhMetaRenderer INSTANCE = new BlazeDhMetaRenderer(); + + + private BlazeDhApplyRenderer applyRenderer; + + public final BlazeTextureWrapper dhDepthTextureWrapper = BlazeTextureWrapper.createDepth("DhDepthTexture"); + public final BlazeTextureWrapper dhColorTextureWrapper = BlazeTextureWrapper.createColor("DhColorTexture"); + + + + //=============// + // constructor // + //=============// + //region + + private BlazeDhMetaRenderer() + { + this.applyRenderer = new BlazeDhApplyRenderer( + "dh_apply_to_mc", + null, + "apply/blaze/vert", "apply/blaze/frag" + ); + } + + //endregion + + + + //=================// + // pre/post render // + //=================// + //region + + @Override + public void runRenderPassSetup(RenderParams renderParams) + { + // textures + this.dhDepthTextureWrapper.tryCreateOrResize(); + this.dhColorTextureWrapper.tryCreateOrResize(); + } + + @Override + public void runRenderPassCleanup(RenderParams renderParams) {} + + @Override + public void applyToMcTexture() + { + GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); + this.applyRenderer.render(this.dhColorTextureWrapper.texture, this.dhDepthTextureWrapper.texture, mcColorTexture); + } + + //endregion + + + + //================// + // clear textures // + //================// + //region + + @Override + public void clearDhDepthAndColorTextures(RenderParams renderParams) + { + // TODO use for clear color + //IMinecraftRenderWrapper r; + //r.getSkyColor() + + this.dhDepthTextureWrapper.clearDepth(1.0f); + this.dhColorTextureWrapper.clearColor(ColorUtil.argbToInt(1, 1, 1, 1)); + } + + //endregion + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java index 79395445b..7e7c1cd18 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -8,6 +8,7 @@ import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanill import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestTriangleRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; @@ -19,6 +20,7 @@ public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition { public String getApiName() { return "Blaze3D"; } + @Override public IDhMetaRenderer getMetaRenderer() { return BlazeDhMetaRenderer.INSTANCE; } @Override public IDhTerrainRenderer getTerrainRenderer() { return BlazeDhTerrainRenderer.INSTANCE; } @Override public IDhSsaoRenderer getSsaoRenderer() { return BlazeDhSsaoRenderer.INSTANCE; } @Override public IDhFogRenderer getFogRenderer() { return BlazeDhFogRenderer.INSTANCE; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index 2408ff194..fef5fcf61 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -63,8 +63,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer public static final BlazeDhTerrainRenderer INSTANCE = new BlazeDhTerrainRenderer(); - private BlazeDhApplyRenderer applyRenderer; - private RenderPipeline opaquePipeline; private RenderPipeline transparentPipeline; private boolean init = false; @@ -74,9 +72,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer private GpuBuffer fragUniformBuffer; private GpuBuffer vertSharedUniformBuffer; - public final BlazeTextureWrapper dhDepthTextureWrapper = BlazeTextureWrapper.createDepth("DhDepthTexture"); - public final BlazeTextureWrapper dhColorTextureWrapper = BlazeTextureWrapper.createColor("DhColorTexture"); - //=============// @@ -95,12 +90,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer this.init = true; // todo only set when succeeded (in case of exception) - this.applyRenderer = new BlazeDhApplyRenderer( - "dh_apply_to_mc", - null, - "apply/blaze/vert", "apply/blaze/frag" - ); - VertexFormat vertexFormat = VertexFormat.builder() .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) .add("meta", DhBlazeVertexFormatUtil.META) @@ -293,10 +282,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer } } - // textures - this.dhDepthTextureWrapper.tryCreateOrResize(); - this.dhColorTextureWrapper.tryCreateOrResize(); - // render pass setup @@ -309,9 +294,9 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer try(RenderPass renderPass = COMMAND_ENCODER.createRenderPass( this::getRenderPassName, - this.dhColorTextureWrapper.textureView, + BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureView, optionalClearColorAsInt, - this.dhDepthTextureWrapper.textureView, optionalDepthValueAsDouble) + BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, optionalDepthValueAsDouble) ) { // bind MC Lightmap @@ -392,24 +377,6 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer private String getIndexBufferName() { return "distantHorizons:LodIndexBuffer"; } private String getRenderPassName() { return "distantHorizons:McLodRenderer"; } - - @Override - public void runRenderPassSetup(RenderParams renderParams) {} - @Override - public void runRenderPassCleanup(RenderParams renderParams) {} - - @Override - public void applyToMcTexture() - { - GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); - this.applyRenderer.render(this.dhColorTextureWrapper.texture, this.dhDepthTextureWrapper.texture, mcColorTexture); - } - - @Override - public void clearDepth() { this.dhDepthTextureWrapper.clearDepth(1.0f); } - @Override - public void clearColor() { this.dhColorTextureWrapper.clearColor(ColorUtil.argbToInt(1, 1, 1, 1)); } - //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index 678c772cc..2eeb400aa 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -32,6 +32,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; @@ -136,8 +137,8 @@ public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer this.tryInit(); - if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -191,7 +192,7 @@ public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer this.renderFadeToTexture(); - BlazeDhCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper); + BlazeDhCopyRenderer.INSTANCE.render(this.dhFadeColorTextureWrapper, BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper); } @@ -208,8 +209,8 @@ public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer renderPass.bindTexture("uMcColorTexture", this.mcColorTextureViewWrapper.textureView, this.mcColorTextureViewWrapper.textureSampler); // DH textures - renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); - renderPass.bindTexture("uDhColorTexture", BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index 8dab2b0dd..850294197 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -39,6 +39,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; @@ -154,8 +155,8 @@ public class BlazeDhFogRenderer implements IDhFogRenderer this.tryInit(); - if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -308,7 +309,7 @@ public class BlazeDhFogRenderer implements IDhFogRenderer this.renderFogToTexture(); - this.applyRenderer.render(this.fogColorTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.texture); + this.applyRenderer.render(this.fogColorTextureWrapper.texture, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.texture); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index 384522bb1..1cc172be7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -36,6 +36,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; @@ -145,8 +146,8 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer this.tryInit(); - if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -244,7 +245,7 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer this.renderSsaoToTexture(); this.applyRenderer.setUniform("applyFragUniformBlock", this.applyFragUniformBuffer); - this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.texture); + this.applyRenderer.render(this.ssaoColorTextureWrapper.texture, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.texture, BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.texture); } @@ -257,7 +258,7 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer /*depthTexture*/ null, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index cddb258a4..e064535b9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -32,6 +32,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; @@ -144,8 +145,8 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer { this.tryInit(); - if (BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() - || BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) + if (BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.isEmpty() + || BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.isEmpty()) { return; } @@ -236,8 +237,8 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer renderPass.bindTexture("uMcDepthTexture", this.mcDepthTextureWrapper.textureView, this.mcDepthTextureWrapper.textureSampler); renderPass.bindTexture("uCombinedMcDhColorTexture", this.mcColorTextureWrapper.textureView, this.mcColorTextureWrapper.textureSampler); - renderPass.bindTexture("uDhDepthTexture", BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); - renderPass.bindTexture("uDhColorTexture", BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhTerrainRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); + renderPass.bindTexture("uDhColorTexture", BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhColorTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java index f0d6ae07e..7650d25aa 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -35,7 +35,6 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribut import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePostGL43; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePreGL43; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; import com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat.LodVertexFormat; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; @@ -47,23 +46,19 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; -import com.seibel.distanthorizons.core.render.RenderBufferHandler; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; -import org.jetbrains.annotations.Nullable; import org.lwjgl.opengl.GL32; /** @@ -72,9 +67,23 @@ import org.lwjgl.opengl.GL32; */ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShaderProgram, IDhTerrainRenderer { + public static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .build(); + + public static final DhTerrainShaderProgram INSTANCE = new DhTerrainShaderProgram(); + + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); + + + + public QuadElementBuffer quadIBO = null; public final AbstractVertexAttribute vao; - // Uniforms + // uniforms // + //region + public int uCombinedMatrix = -1; public int uModelOffset = -1; public int uWorldYOffset = -1; @@ -96,6 +105,8 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade // Debug Uniform public int uIsWhiteWorld = -1; + //endregion + //=============// @@ -103,8 +114,7 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade //=============// //region - // This will bind AbstractVertexAttribute - public DhTerrainShaderProgram() + private DhTerrainShaderProgram() { super( "shaders/standard.vert", @@ -169,9 +179,9 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade - //=========// - // methods // - //=========// + //=============// + // API methods // + //=============// //region @Override @@ -260,533 +270,128 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade + //===========// + // rendering // + //===========// + //region @Override - public void runRenderPassSetup(RenderParams renderParams) { OpenGlRenderState.INSTANCE.runRenderPassSetup(renderParams); } - - @Override - public void runRenderPassCleanup(RenderParams renderParams) { OpenGlRenderState.INSTANCE.runRenderPassCleanup(renderParams); } - - - @Override public void render(RenderParams renderEventParam, boolean opaquePass, SortedArraySet bufferContainers, IProfilerWrapper profiler) { - OpenGlRenderState.INSTANCE.renderLodTerrain(bufferContainers, renderEventParam, opaquePass); - } - @Override - public void applyToMcTexture() - { - } - @Override - public void clearDepth() - { - } - @Override - public void clearColor() - { - } - - - public static class OpenGlRenderState - { - public static final DhLogger LOGGER = new DhLoggerBuilder() - .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) - .build(); + //=======================// + // debug wireframe setup // + //=======================// - public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() - .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) - .maxCountPerSecond(4) - .build(); - - public static final OpenGlRenderState INSTANCE = new OpenGlRenderState(); - - - private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); - private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; - private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); - - - // these ID's either what any render is currently using (since only one renderer can be active at a time), or just used previously - private int activeFramebufferId = -1; - private int activeColorTextureId = -1; - private int activeDepthTextureId = -1; - private int textureWidth; - private int textureHeight; - - - private IDhApiShaderProgram lodRenderProgram = null; - public QuadElementBuffer quadIBO = null; - private boolean renderObjectsCreated = false; - - // framebuffer and texture ID's for this renderer - private IDhApiFramebuffer framebuffer; - /** will be null if MC's framebuffer is being used since MC already has a color texture */ - @Nullable - private DhColorTexture nullableColorTexture; - private DHDepthTexture depthTexture; - /** - * If true the {@link OpenGlRenderState#framebuffer} is the same as MC's. - * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. - */ - private boolean usingMcFramebuffer = false; - - - private IDhApiShaderProgram lodShaderProgramThisFrame; - - - // - // - // - - public void runRenderPassSetup(RenderParams renderParams) + boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); + if (renderWireframe) { - boolean firstPass = - (renderParams.renderPass == EDhApiRenderPass.OPAQUE - || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); - - if (!this.renderObjectsCreated) - { - boolean setupSuccess = this.createRenderObjects(); - if (!setupSuccess) - { - // shouldn't normally happen, but just in case - return; - } - - this.renderObjectsCreated = true; - } - - - this.setGLState(renderParams, firstPass); - - this.quadIBO.bind(); - renderParams.lightmap.bind(); - - this.lodShaderProgramThisFrame = this.lodRenderProgram; - IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); - if (lodShaderProgramOverride != null && this.lodShaderProgramThisFrame.overrideThisFrame()) - { - this.lodShaderProgramThisFrame = lodShaderProgramOverride; - } - + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); + GLMC.disableFaceCulling(); } - - public void runRenderPassCleanup(RenderParams renderParams) + else { - boolean runningDeferredPass = (renderParams.renderPass == EDhApiRenderPass.TRANSPARENT); - - - if (!runningDeferredPass) - { - //===================// - // optifine clean up // - //===================// - - if (this.usingMcFramebuffer) - { - // If MC's framebuffer is being used the depth needs to be cleared to prevent rendering on top of MC. - // This should only happen when Optifine shaders are being used. - GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); - } - - - - //=============================// - // Apply to the MC Framebuffer // - //=============================// - - boolean cancelApplyShader = ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeApplyShaderRenderEvent.class, renderParams); - if (!cancelApplyShader) - { - //profiler.popPush("LOD Apply"); - - // Copy the LOD framebuffer to Minecraft's framebuffer - DhApplyShader.INSTANCE.render(renderParams.partialTicks); - } - } - - - renderParams.lightmap.unbind(); - this.quadIBO.unbind(); - this.lodShaderProgramThisFrame.unbind(); - } - - - - //=================// - // Setup Functions // - //=================// - //region - - private void setGLState( - DhApiRenderParam renderEventParam, - boolean firstPass) - { - //===================// - // framebuffer setup // - //===================// - - // get the active framebuffer - IDhApiFramebuffer framebuffer = this.framebuffer; - IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); - if (framebufferOverride != null && framebufferOverride.overrideThisFrame()) - { - framebuffer = framebufferOverride; - } - this.activeFramebufferId = framebuffer.getId(); - framebuffer.bind(); - - - - //==========// - // bindings // - //==========// - - // by default draw everything as triangles GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); GLMC.enableFaceCulling(); - - GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); - GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); - - GL32.glDisable(GL32.GL_SCISSOR_TEST); - - // Enable depth test and depth mask + } + + if (!opaquePass) + { + GLMC.enableBlend(); GLMC.enableDepthTest(); - GLMC.glDepthFunc(GL32.GL_LESS); - GLMC.enableDepthMask(); - - // This is required for MC versions 1.21.5+ - // due to MC updating the lightmap by changing the viewport size - GL32.glViewport(0, 0, this.textureWidth, this.textureHeight); - - this.lodRenderProgram.bind(); - - - - //==========// - // uniforms // - //==========// - - IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); - if (shaderProgramOverride != null) - { - shaderProgramOverride.fillUniformData(renderEventParam); - } - - this.lodRenderProgram.fillUniformData(renderEventParam); - - - - //===============// - // texture setup // - //===============// - - // resize the textures if needed - if (MC_RENDER.getTargetFramebufferViewportWidth() != this.textureWidth - || MC_RENDER.getTargetFramebufferViewportHeight() != this.textureHeight) - { - // just resizing the textures doesn't work when Optifine is present, - // so recreate the textures with the new size instead - this.createAndBindTextures(); - } - - - // set the active textures - this.activeDepthTextureId = this.depthTexture.getTextureId(); - - if (this.nullableColorTexture != null) - { - this.activeColorTextureId = this.nullableColorTexture.getTextureId(); - } - else - { - // get MC's color texture - this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); - } - - - // needs to be fired after all the textures have been created/bound - boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderEventParam); - if (clearTextures) - { - GL32.glClearDepth(1.0); - - float[] clearColorValues = new float[4]; - GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); - GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); - - if (this.usingMcFramebuffer && framebufferOverride == null) - { - // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, - // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues - framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - - - // don't clear the color texture, that removes the sky - GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); - } - else if (firstPass) - { - GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); - } - } + GL32.glBlendEquation(GL32.GL_FUNC_ADD); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); + } + else + { + GLMC.disableBlend(); } - private boolean createRenderObjects() + + + + //===========// + // rendering // + //===========// + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam); + + if (IRIS_ACCESSOR != null) { - if (this.renderObjectsCreated) - { - LOGGER.warn("Renderer setup called but it has already completed setup!"); - return false; - } - - // GLProxy should have already been created by this point, but just in case create it now - GLProxy.getInstance(); - - - - LOGGER.info("Setting up renderer"); - this.lodRenderProgram = new DhTerrainShaderProgram(); - - this.quadIBO = new QuadElementBuffer(); - this.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); - - - // create or get the frame buffer - if (AbstractOptifineAccessor.optifinePresent()) - { - // use MC/Optifine's default Framebuffer so shaders won't remove the LODs - int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); - this.framebuffer = new DhFramebuffer(currentFramebufferId); - this.usingMcFramebuffer = true; - } - else - { - // normal use case - this.framebuffer = new DhFramebuffer(); - this.usingMcFramebuffer = false; - } - - // create and bind the necessary textures - this.createAndBindTextures(); - - if(this.framebuffer.getStatus() != GL32.GL_FRAMEBUFFER_COMPLETE) - { - // This generally means something wasn't bound, IE missing either the color or depth texture - LOGGER.warn("Framebuffer ["+this.framebuffer.getId()+"] isn't complete."); - return false; - } - - - - LOGGER.info("Renderer setup complete"); - return true; + // done to fix a bug with Iris where face culling isn't properly set or reverted in the MC state manager + // which causes Sodium to render some water chunks with their normals inverted + // https://github.com/IrisShaders/Iris/issues/2582 + // https://github.com/IrisShaders/Iris/blob/1.21.9/common/src/main/java/net/irisshaders/iris/compat/dh/LodRendererEvents.java#L346 + GLMC.enableFaceCulling(); } - @SuppressWarnings( "deprecation" ) // done to ignore DhApiColorDepthTextureCreatedEvent - private void createAndBindTextures() + + if (bufferContainers != null) { - int oldWidth = this.textureWidth; - int oldHeight = this.textureHeight; - this.textureWidth = MC_RENDER.getTargetFramebufferViewportWidth(); - this.textureHeight = MC_RENDER.getTargetFramebufferViewportHeight(); - - DhApiTextureCreatedParam textureCreatedParam = new DhApiTextureCreatedParam( - oldWidth, oldHeight, - this.textureWidth, this.textureHeight - ); - - - // DhApiColorDepthTextureCreatedEvent needs to be kept around since old versions of Iris need it - ApiEventInjector.INSTANCE.fireAllEvents(DhApiColorDepthTextureCreatedEvent.class, new DhApiColorDepthTextureCreatedEvent.EventParam(textureCreatedParam)); - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeColorDepthTextureCreatedEvent.class, textureCreatedParam); - - - // also update the framebuffer override if present - IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); - - - this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); - this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - if (framebufferOverride != null) + for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) { - framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); - } - - - // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound - if (!this.usingMcFramebuffer) - { - this.nullableColorTexture = DhColorTexture.builder() - .setDimensions(this.textureWidth, this.textureHeight) - .setInternalFormat(EDhInternalTextureFormat.RGBA8) - .setPixelType(EDhPixelType.UNSIGNED_BYTE) - .setPixelFormat(EDhPixelFormat.RGBA) - .build(); + LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); + this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame, renderEventParam); - this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); - if (framebufferOverride != null) + IVertexBufferWrapper[] vertexBuffers = (opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent); + for (int vboIndex = 0; vboIndex < vertexBuffers.length; vboIndex++) { - framebufferOverride.addColorAttachment(0, this.nullableColorTexture.getTextureId()); - } - } - else - { - this.nullableColorTexture = null; - } - - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterColorDepthTextureCreatedEvent.class, textureCreatedParam); - } - - //endregion - - - - //===============// - // LOD rendering // - //===============// - //region - - public void renderLodTerrain(SortedArraySet bufferContainers, RenderParams renderEventParam, boolean opaquePass) - { - IDhApiShaderProgram shaderProgram = this.lodShaderProgramThisFrame; - - //=======================// - // debug wireframe setup // - //=======================// - - boolean renderWireframe = Config.Client.Advanced.Debugging.renderWireframe.get(); - if (renderWireframe) - { - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_LINE); - GLMC.disableFaceCulling(); - } - else - { - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - GLMC.enableFaceCulling(); - } - - if (!opaquePass) - { - GLMC.enableBlend(); - GLMC.enableDepthTest(); - GL32.glBlendEquation(GL32.GL_FUNC_ADD); - GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); - } - else - { - GLMC.disableBlend(); - } - - - - - //===========// - // rendering // - //===========// - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeRenderPassEvent.class, renderEventParam); - - if (IRIS_ACCESSOR != null) - { - // done to fix a bug with Iris where face culling isn't properly set or reverted in the MC state manager - // which causes Sodium to render some water chunks with their normal inverted - // https://github.com/IrisShaders/Iris/issues/2582 - // https://github.com/IrisShaders/Iris/blob/1.21.9/common/src/main/java/net/irisshaders/iris/compat/dh/LodRendererEvents.java#L346 - GLMC.enableFaceCulling(); - } - - - if (bufferContainers != null) - { - for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) - { - LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, shaderProgram, renderEventParam); - - IVertexBufferWrapper[] vertexBuffers = (opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent); - for (int vboIndex = 0; vboIndex < vertexBuffers.length; vboIndex++) + GLVertexBuffer vbo = (GLVertexBuffer) vertexBuffers[vboIndex]; + if (vbo == null) { - GLVertexBuffer vbo = (GLVertexBuffer) vertexBuffers[vboIndex]; - if (vbo == null) - { - continue; - } - - if (vbo.getVertexCount() == 0) - { - continue; - } - - vbo.bind(); - shaderProgram.bindVertexBuffer(vbo.getId()); - GL32.glDrawElements( - GL32.GL_TRIANGLES, - (int)(vbo.getVertexCount() * 1.5), - this.quadIBO.getType(), 0); - vbo.unbind(); + continue; } + + if (vbo.getVertexCount() == 0) + { + continue; + } + + vbo.bind(); + OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bindVertexBuffer(vbo.getId()); + GL32.glDrawElements( + GL32.GL_TRIANGLES, + (int)(vbo.getVertexCount() * 1.5), + this.quadIBO.getType(), 0); + vbo.unbind(); } } - - - - //=========================// - // debug wireframe cleanup // - //=========================// - - if (renderWireframe) - { - // default back to GL_FILL since all other rendering uses it - GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); - GLMC.enableFaceCulling(); - } - } - /** - * the MVM offset is needed so LODs can be rendered anywhere in the MC world - * without running into floating point percision loss. - */ - private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException + + + //=========================// + // debug wireframe cleanup // + //=========================// + + if (renderWireframe) { - Vec3d camPos = renderEventParam.exactCameraPosition; - Vec3f modelPos = new Vec3f( - (float) (pos.getX() - camPos.x), - (float) (pos.getY() - camPos.y), - (float) (pos.getZ() - camPos.z)); - - shaderProgram.bind(); - shaderProgram.setModelOffsetPos(modelPos); - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + // default back to GL_FILL since all other rendering uses it + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); } - //endregion - - - - //===============// - // API functions // - //===============// - //region - - /** @return -1 if no frame buffer has been bound yet */ - public int getActiveFramebufferId() { return this.activeFramebufferId; } - - /** @return -1 if no texture has been bound yet */ - public int getActiveColorTextureId() { return this.activeColorTextureId; } - - /** @return -1 if no texture has been bound yet */ - public int getActiveDepthTextureId() { return this.activeDepthTextureId; } - - //endregion - - } + /** + * the MVM offset is needed so LODs can be rendered anywhere in the MC world + * without running into floating point percision loss. + */ + private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelPos = new Vec3f( + (float) (pos.getX() - camPos.x), + (float) (pos.getY() - camPos.y), + (float) (pos.getZ() - camPos.z)); + + shaderProgram.bind(); + shaderProgram.setModelOffsetPos(modelPos); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + } + + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java new file mode 100644 index 000000000..2fb7143f3 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java @@ -0,0 +1,448 @@ +package com.seibel.distanthorizons.common.render.nativeGl; + +import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass; +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; +import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; +import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; +import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; +import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.core.config.Config; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; +import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; +import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; +import com.seibel.distanthorizons.core.render.RenderParams; +import com.seibel.distanthorizons.core.util.ColorUtil; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.util.math.Vec3f; +import com.seibel.distanthorizons.core.util.objects.SortedArraySet; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhMetaRenderer; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; +import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; +import org.jetbrains.annotations.Nullable; +import org.lwjgl.opengl.GL32; + +public class OpenGlDhMetaRenderer implements IDhMetaRenderer +{ + public static final DhLogger LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .build(); + + public static final DhLogger RATE_LIMITED_LOGGER = new DhLoggerBuilder() + .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) + .maxCountPerSecond(4) + .build(); + + public static final OpenGlDhMetaRenderer INSTANCE = new OpenGlDhMetaRenderer(); + + + private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); + private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; + + + private int activeFramebufferId = -1; + private int activeColorTextureId = -1; + private int activeDepthTextureId = -1; + private int textureWidth; + private int textureHeight; + + + // framebuffer and texture ID's for this renderer + private IDhApiFramebuffer framebuffer; + /** will be null if MC's framebuffer is being used since MC already has a color texture */ + @Nullable + private DhColorTexture nullableColorTexture; + private DHDepthTexture depthTexture; + /** + * If true the {@link OpenGlDhMetaRenderer#framebuffer} is the same as MC's. + * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. + */ + private boolean usingMcFramebuffer = false; + + private boolean renderObjectsCreated = false; + /** used in case there's an API override */ + public IDhApiShaderProgram shaderProgramForThisFrame; + + + + //============// + // pre render // + //============// + //region + + @Override + public void runRenderPassSetup(RenderParams renderParams) + { + boolean firstPass = + (renderParams.renderPass == EDhApiRenderPass.OPAQUE + || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); + + if (!this.renderObjectsCreated) + { + boolean setupSuccess = this.createRenderObjects(); + if (!setupSuccess) + { + // shouldn't normally happen, but just in case + return; + } + + this.renderObjectsCreated = true; + } + + this.shaderProgramForThisFrame = DhTerrainShaderProgram.INSTANCE; + IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (lodShaderProgramOverride != null && this.shaderProgramForThisFrame.overrideThisFrame()) + { + this.shaderProgramForThisFrame = lodShaderProgramOverride; + } + + + this.setGLState(renderParams, firstPass); + + DhTerrainShaderProgram.INSTANCE.quadIBO.bind(); + renderParams.lightmap.bind(); + } + private void setGLState( + DhApiRenderParam renderEventParam, + boolean firstPass) + { + //===================// + // framebuffer setup // + //===================// + + // get the active framebuffer + IDhApiFramebuffer framebuffer = this.framebuffer; + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + if (framebufferOverride != null && framebufferOverride.overrideThisFrame()) + { + framebuffer = framebufferOverride; + } + this.activeFramebufferId = framebuffer.getId(); + framebuffer.bind(); + + + + //==========// + // bindings // + //==========// + + // by default draw everything as triangles + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); + GLMC.enableFaceCulling(); + + GLMC.glBlendFunc(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA); + GLMC.glBlendFuncSeparate(GL32.GL_SRC_ALPHA, GL32.GL_ONE_MINUS_SRC_ALPHA, GL32.GL_ONE, GL32.GL_ZERO); + + GL32.glDisable(GL32.GL_SCISSOR_TEST); + + // Enable depth test and depth mask + GLMC.enableDepthTest(); + GLMC.glDepthFunc(GL32.GL_LESS); + GLMC.enableDepthMask(); + + // This is required for MC versions 1.21.5+ + // due to MC updating the lightmap by changing the viewport size + GL32.glViewport(0, 0, this.textureWidth, this.textureHeight); + + this.shaderProgramForThisFrame.bind(); + + + + //==========// + // uniforms // + //==========// + + IDhApiShaderProgram shaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); + if (shaderProgramOverride != null) + { + shaderProgramOverride.fillUniformData(renderEventParam); + } + + this.shaderProgramForThisFrame.fillUniformData(renderEventParam); + + + + //===============// + // texture setup // + //===============// + + // resize the textures if needed + if (MC_RENDER.getTargetFramebufferViewportWidth() != this.textureWidth + || MC_RENDER.getTargetFramebufferViewportHeight() != this.textureHeight) + { + // just resizing the textures doesn't work when Optifine is present, + // so recreate the textures with the new size instead + this.createAndBindTextures(); + } + + + // set the active textures + this.activeDepthTextureId = this.depthTexture.getTextureId(); + + if (this.nullableColorTexture != null) + { + this.activeColorTextureId = this.nullableColorTexture.getTextureId(); + } + else + { + // get MC's color texture + this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + } + + + // needs to be fired after all the textures have been created/bound + boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderEventParam); + if (clearTextures) + { + GL32.glClearDepth(1.0); + + float[] clearColorValues = new float[4]; + GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); + GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); + + if (this.usingMcFramebuffer && framebufferOverride == null) + { + // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, + // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues + framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + + + // don't clear the color texture, that removes the sky + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + else if (firstPass) + { + GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + } + } + } + + private boolean createRenderObjects() + { + if (this.renderObjectsCreated) + { + LOGGER.warn("Renderer setup called but it has already completed setup!"); + return false; + } + + // GLProxy should have already been created by this point, but just in case create it now + GLProxy.getInstance(); + + + + LOGGER.info("Setting up renderer"); + + DhTerrainShaderProgram.INSTANCE.quadIBO = new QuadElementBuffer(); + DhTerrainShaderProgram.INSTANCE.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); + + + // create or get the frame buffer + if (AbstractOptifineAccessor.optifinePresent()) + { + // use MC/Optifine's default Framebuffer so shaders won't remove the LODs + int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); + this.framebuffer = new DhFramebuffer(currentFramebufferId); + this.usingMcFramebuffer = true; + } + else + { + // normal use case + this.framebuffer = new DhFramebuffer(); + this.usingMcFramebuffer = false; + } + + // create and bind the necessary textures + this.createAndBindTextures(); + + if(this.framebuffer.getStatus() != GL32.GL_FRAMEBUFFER_COMPLETE) + { + // This generally means something wasn't bound, IE missing either the color or depth texture + LOGGER.warn("Framebuffer ["+this.framebuffer.getId()+"] isn't complete."); + return false; + } + + + + LOGGER.info("Renderer setup complete"); + return true; + } + + @SuppressWarnings( "deprecation" ) // done to ignore DhApiColorDepthTextureCreatedEvent + private void createAndBindTextures() + { + int oldWidth = this.textureWidth; + int oldHeight = this.textureHeight; + this.textureWidth = MC_RENDER.getTargetFramebufferViewportWidth(); + this.textureHeight = MC_RENDER.getTargetFramebufferViewportHeight(); + + DhApiTextureCreatedParam textureCreatedParam = new DhApiTextureCreatedParam( + oldWidth, oldHeight, + this.textureWidth, this.textureHeight + ); + + + // DhApiColorDepthTextureCreatedEvent needs to be kept around since old versions of Iris need it + ApiEventInjector.INSTANCE.fireAllEvents(DhApiColorDepthTextureCreatedEvent.class, new DhApiColorDepthTextureCreatedEvent.EventParam(textureCreatedParam)); + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeColorDepthTextureCreatedEvent.class, textureCreatedParam); + + + // also update the framebuffer override if present + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + + + this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); + this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + if (framebufferOverride != null) + { + framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + } + + + // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound + if (!this.usingMcFramebuffer) + { + this.nullableColorTexture = DhColorTexture.builder() + .setDimensions(this.textureWidth, this.textureHeight) + .setInternalFormat(EDhInternalTextureFormat.RGBA8) + .setPixelType(EDhPixelType.UNSIGNED_BYTE) + .setPixelFormat(EDhPixelFormat.RGBA) + .build(); + + this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + if (framebufferOverride != null) + { + framebufferOverride.addColorAttachment(0, this.nullableColorTexture.getTextureId()); + } + } + else + { + this.nullableColorTexture = null; + } + + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiAfterColorDepthTextureCreatedEvent.class, textureCreatedParam); + } + + //endregion + + + + //=============// + // post render // + //=============// + //region + + @Override + public void runRenderPassCleanup(RenderParams renderParams) + { + boolean runningDeferredPass = (renderParams.renderPass == EDhApiRenderPass.TRANSPARENT); + if (!runningDeferredPass) + { + //===================// + // optifine clean up // + //===================// + + if (this.usingMcFramebuffer) + { + // If MC's framebuffer is being used the depth needs to be cleared to prevent rendering on top of MC. + // This should only happen when Optifine shaders are being used. + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + } + + + renderParams.lightmap.unbind(); + DhTerrainShaderProgram.INSTANCE.quadIBO.unbind(); + this.shaderProgramForThisFrame.unbind(); + } + + @Override + public void applyToMcTexture() { DhApplyShader.INSTANCE.render(0.0f); } + + //endregion + + + + //================// + // clear textures // + //================// + //region + + @Override + public void clearDhDepthAndColorTextures(RenderParams renderParams) + { + IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); + + boolean firstPass = + (renderParams.renderPass == EDhApiRenderPass.OPAQUE + || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); + + + + // needs to be fired after all the textures have been created/bound + boolean clearTextures = !ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeTextureClearEvent.class, renderParams); + if (clearTextures) + { + GL32.glClearDepth(1.0); + + float[] clearColorValues = new float[4]; + GL32.glGetFloatv(GL32.GL_COLOR_CLEAR_VALUE, clearColorValues); + GL32.glClearColor(clearColorValues[0], clearColorValues[1], clearColorValues[2], 1.0f); + + if (this.usingMcFramebuffer + && framebufferOverride == null) + { + //// Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, + //// otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues + //this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + + + // don't clear the color texture, that removes the sky + GL32.glClear(GL32.GL_DEPTH_BUFFER_BIT); + } + else if (firstPass) + { + GL32.glClear(GL32.GL_COLOR_BUFFER_BIT | GL32.GL_DEPTH_BUFFER_BIT); + } + } + + } + + //endregion + + + + //===============// + // API functions // + //===============// + //region + + /** @return -1 if no frame buffer has been bound yet */ + public int getActiveFramebufferId() { return this.activeFramebufferId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveColorTextureId() { return this.activeColorTextureId; } + + /** @return -1 if no texture has been bound yet */ + public int getActiveDepthTextureId() { return this.activeDepthTextureId; } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java index 5b24d3d47..a00fa7236 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java @@ -21,7 +21,8 @@ public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition public String getApiName() { return "OpenGL"; } - @Override public IDhTerrainRenderer getTerrainRenderer() { return new DhTerrainShaderProgram(); } // TODO not implemented // TODO how to support Iris? + @Override public IDhMetaRenderer getMetaRenderer() { return OpenGlDhMetaRenderer.INSTANCE; } + @Override public IDhTerrainRenderer getTerrainRenderer() { return DhTerrainShaderProgram.INSTANCE; } // TODO how to support Iris? @Override public IDhSsaoRenderer getSsaoRenderer() { return DhSSAORenderer.INSTANCE; } @Override public IDhFogRenderer getFogRenderer() { return DhFogRenderer.INSTANCE; } @Override public IDhFarFadeRenderer getFarFadeRenderer() { return DhFarFadeRenderer.INSTANCE; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java index 542780d7c..84b8b3b8d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; @@ -117,11 +118,11 @@ public class DhApplyShader extends AbstractShaderRenderer //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); // Copy to MC's framebuffer @@ -141,7 +142,7 @@ public class DhApplyShader extends AbstractShaderRenderer return; } - int dhFrameBufferId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId(); + int dhFrameBufferId = OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); if (dhFrameBufferId == -1) { return; @@ -165,11 +166,11 @@ public class DhApplyShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java index 785ebd9fc..e09fa92b3 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -145,7 +146,7 @@ public class DhFarFadeRenderer implements IDhFarFadeRenderer DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; - DhFarFadeApplyShader.INSTANCE.drawFramebuffer = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId(); + DhFarFadeApplyShader.INSTANCE.drawFramebuffer = OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); DhFarFadeApplyShader.INSTANCE.render(0.0f); } catch (Exception e) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java index 941367df1..24944b228 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -128,8 +129,8 @@ public class DhFarFadeShader extends AbstractShaderRenderer @Override protected void onRender() { - int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId(); + int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java index 592148d97..f26b0b7cb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -125,7 +126,7 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer @Override public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) { - int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); + int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); if (depthTextureId == -1) { // the renderer hasn't been set up yet diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java index 6bc666ac3..354affe93 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -164,8 +165,8 @@ public class VanillaFadeShader extends AbstractShaderRenderer @Override protected void onRender() { - int depthTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveColorTextureId(); + int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java index 6fa439e6d..13f8f7177 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -81,7 +82,7 @@ public class FogApplyShader extends AbstractShaderRenderer GL32.glUniform1i(this.colorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.depthTextureUniform, 1); } @@ -107,7 +108,7 @@ public class FogApplyShader extends AbstractShaderRenderer // apply the rendered Fog to DH's framebuffer GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, FogShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); ScreenQuad.INSTANCE.render(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java index 289a59c22..f81a921b6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java @@ -24,6 +24,7 @@ import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -266,7 +267,7 @@ public class FogShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.uDepthMap, 0); // this is necessary for MC 1.16 (IE Legacy OpenGL) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java index 86569beeb..9a23a5194 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java @@ -20,6 +20,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -85,7 +86,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer protected void onApplyUniforms(float partialTicks) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); @@ -134,7 +135,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer // apply the rendered SSAO to the LODs GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, SSAOShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); ScreenQuad.INSTANCE.render(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java index bcf66f88f..c09e8da3c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; +import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -133,7 +134,7 @@ public class SSAOShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(DhTerrainShaderProgram.OpenGlRenderState.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); ScreenQuad.INSTANCE.render(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java index 9e6d5368c..6f9518dd5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java @@ -133,6 +133,8 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer this.va.bindBufferToAllBindingPoints(this.vbo.getId()); GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 3); + + DhApplyShader.INSTANCE.render(0.0f); } //endregion diff --git a/coreSubProjects b/coreSubProjects index 1b0f93db0..0362d8917 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 1b0f93db07eb071eb74294a58e6e4e6f385acf7d +Subproject commit 0362d89173523c21bf198e6a7481a8bb75d23290 From 89619696cbc4b43edc56b6732b58ec5f1f7e298d Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 16:45:58 -0500 Subject: [PATCH 53/72] fix iris rendering --- .../common/AbstractModInitializer.java | 45 ++++++++++++++++++- .../blaze/BlazeDhRenderApiDefinition.java | 26 ++++++++++- .../nativeGl/DhTerrainShaderProgram.java | 41 ++++++----------- .../render/nativeGl/OpenGlDhMetaRenderer.java | 37 ++++++++------- .../nativeGl/OpenGlDhRenderApiDefinition.java | 27 ++++++++++- .../glObject/texture/DhFramebuffer.java | 27 ++++++----- .../common/wrappers/VersionConstants.java | 38 ++++++++++++---- coreSubProjects | 2 +- 8 files changed, 172 insertions(+), 71 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java index 538f16fdd..aba9025e4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java @@ -1,6 +1,7 @@ package com.seibel.distanthorizons.common; import com.mojang.brigadier.CommandDispatcher; +import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiAfterDhInitEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeDhInitEvent; import com.seibel.distanthorizons.common.commands.CommandInitializer; @@ -18,6 +19,10 @@ import com.seibel.distanthorizons.core.enums.MinecraftTextFormat; import com.seibel.distanthorizons.core.jar.ModJarInfo; import com.seibel.distanthorizons.core.jar.updater.SelfUpdater; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.util.NativeDialogUtil; +import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IModChecker; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; @@ -244,6 +249,7 @@ public abstract class AbstractModInitializer // Alex's caves + //region if (modChecker.isModLoaded("alexscaves")) { // There've been a few reports about this mod breaking DH at a few different points in time @@ -260,8 +266,10 @@ public abstract class AbstractModInitializer LOGGER.warn(startingString + "[Alex's Caves] may require some config changes in order to render Distant Horizons correctly."); } + //endregion // William Wythers' Overhauled Overworld (WWOO) + //region if (modChecker.isModLoaded("wwoo")) { // WWOO has a bug with it's world gen that can't be fixed by DH or WWOO @@ -282,8 +290,11 @@ public abstract class AbstractModInitializer LOGGER.warn(startingString + "[WWOO] "+ wwooWarning); } + //endregion + + // Chunky // + //region - // Chunky boolean chunkyPresent = false; try { @@ -313,6 +324,38 @@ public abstract class AbstractModInitializer LOGGER.warn(startingString + "[Chunky] "+ chunkyWarning); } + //endregion + + // iris // + //region + + IIrisAccessor iris = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); + if (iris != null) + { + // get the currently selected rendering API + EDhApiRenderApi renderApi = Config.Client.Advanced.Graphics.Experimental.renderingApi.get(); + if (renderApi == EDhApiRenderApi.AUTO) + { + IVersionConstants versionConstants = SingletonInjector.INSTANCE.get(IVersionConstants.class); + renderApi = versionConstants.getDefaultRenderer(); + } + + // Iris only supports nataive OpenGL + if (renderApi != EDhApiRenderApi.OPEN_GL) + { + String irisUnsupportedMessage = "Iris doesn't support DH when using the ["+EDhApiRenderApi.BLAZE_3D+"] rendering API, please change it to ["+EDhApiRenderApi.OPEN_GL+"] in DH's config file."; + LOGGER.fatal(irisUnsupportedMessage); + NativeDialogUtil.showDialog(ModInfo.READABLE_NAME, irisUnsupportedMessage, "ok", "error"); + + IMinecraftClientWrapper mc = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + String errorMessage = "loading Distant Horizons. "+irisUnsupportedMessage; + String exceptionError = "Distant Horizons conditional mod config Exception"; + mc.crashMinecraft(errorMessage, new Exception(exceptionError)); + } + } + + //endregion + } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java index 7e7c1cd18..de117e308 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -18,8 +18,22 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition { + //=========// + // getters // + //=========// + //region + public String getApiName() { return "Blaze3D"; } + //endregion + + + + //============// + // singletons // + //============// + //region + @Override public IDhMetaRenderer getMetaRenderer() { return BlazeDhMetaRenderer.INSTANCE; } @Override public IDhTerrainRenderer getTerrainRenderer() { return BlazeDhTerrainRenderer.INSTANCE; } @Override public IDhSsaoRenderer getSsaoRenderer() { return BlazeDhSsaoRenderer.INSTANCE; } @@ -30,13 +44,23 @@ public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return BlazeVanillaFadeRenderer.INSTANCE; } @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return BlazeDhTestTriangleRenderer.INSTANCE; } - @Override public IDhGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } + //endregion + + //===========// + // factories // + //===========// + //region + + @Override public IDhGenericRenderer createGenericRenderer() { return new BlazeDhGenericObjectRenderer(); } + @Override public IVertexBufferWrapper createVboWrapper(String name) { return new BlazeVertexBufferWrapper(name); } @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new BlazeLodUniformBufferWrapper(); } @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new BlazeGenericObjectVertexContainer(); } + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java index 7650d25aa..b150f5593 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -19,18 +19,14 @@ package com.seibel.distanthorizons.common.render.nativeGl; -import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass; -import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; -import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePostGL43; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePreGL43; @@ -42,23 +38,19 @@ import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3d; import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; -import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; import org.lwjgl.opengl.GL32; /** @@ -330,7 +322,20 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade for (int lodIndex = 0; lodIndex < bufferContainers.size(); lodIndex++) { LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - this.setShaderProgramMvmOffset(bufferContainer.minCornerBlockPos, OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame, renderEventParam); + + // set uniforms + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelPos = new Vec3f( + (float) (bufferContainer.minCornerBlockPos.getX() - camPos.x), + (float) (bufferContainer.minCornerBlockPos.getY() - camPos.y), + (float) (bufferContainer.minCornerBlockPos.getZ() - camPos.z)); + + OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bind(); + OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.setModelOffsetPos(modelPos); + + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + } IVertexBufferWrapper[] vertexBuffers = (opaquePass ? bufferContainer.vbos : bufferContainer.vbosTransparent); for (int vboIndex = 0; vboIndex < vertexBuffers.length; vboIndex++) @@ -372,24 +377,6 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade } - /** - * the MVM offset is needed so LODs can be rendered anywhere in the MC world - * without running into floating point percision loss. - */ - private void setShaderProgramMvmOffset(DhBlockPos pos, IDhApiShaderProgram shaderProgram, RenderParams renderEventParam) throws IllegalStateException - { - Vec3d camPos = renderEventParam.exactCameraPosition; - Vec3f modelPos = new Vec3f( - (float) (pos.getX() - camPos.x), - (float) (pos.getY() - camPos.y), - (float) (pos.getZ() - camPos.z)); - - shaderProgram.bind(); - shaderProgram.setModelOffsetPos(modelPos); - - ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); - } - //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java index 2fb7143f3..579f73b44 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java @@ -7,30 +7,19 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; -import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.pos.blockPos.DhBlockPos; +import com.seibel.distanthorizons.core.render.DhApiRenderProxy; import com.seibel.distanthorizons.core.render.RenderParams; -import com.seibel.distanthorizons.core.util.ColorUtil; -import com.seibel.distanthorizons.core.util.math.Vec3d; -import com.seibel.distanthorizons.core.util.math.Vec3f; -import com.seibel.distanthorizons.core.util.objects.SortedArraySet; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.IIrisAccessor; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhMetaRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; @@ -90,7 +79,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer { boolean firstPass = (renderParams.renderPass == EDhApiRenderPass.OPAQUE - || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); + || renderParams.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT); if (!this.renderObjectsCreated) { @@ -132,7 +121,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer { framebuffer = framebufferOverride; } - this.activeFramebufferId = framebuffer.getId(); + this.setActiveFramebufferId(framebuffer.getId()); framebuffer.bind(); @@ -192,16 +181,19 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer // set the active textures - this.activeDepthTextureId = this.depthTexture.getTextureId(); + int depthTextureId = this.depthTexture.getTextureId(); + this.setActiveDepthTextureId(depthTextureId); if (this.nullableColorTexture != null) { - this.activeColorTextureId = this.nullableColorTexture.getTextureId(); + int colorTextureId = this.nullableColorTexture.getTextureId(); + this.setActiveColorTextureId(colorTextureId); } else { // get MC's color texture - this.activeColorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + int colorTextureId = GL32.glGetFramebufferAttachmentParameteri(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0, GL32.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); + this.setActiveColorTextureId(colorTextureId); } @@ -432,12 +424,23 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer //===============// //region + public void setActiveFramebufferId(int id) { this.activeFramebufferId = id; } /** @return -1 if no frame buffer has been bound yet */ public int getActiveFramebufferId() { return this.activeFramebufferId; } + public void setActiveColorTextureId(int id) + { + this.activeColorTextureId = id; + DhApiRenderProxy.activeOpenGlDhColorTextureId = id; + } /** @return -1 if no texture has been bound yet */ public int getActiveColorTextureId() { return this.activeColorTextureId; } + public void setActiveDepthTextureId(int id) + { + this.activeDepthTextureId = id; + DhApiRenderProxy.activeOpenGlDhDepthTextureId = id; + } /** @return -1 if no texture has been bound yet */ public int getActiveDepthTextureId() { return this.activeDepthTextureId; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java index a00fa7236..f86222d66 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java @@ -18,11 +18,24 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition { + //=========// + // getters // + //=========// + //region public String getApiName() { return "OpenGL"; } + //endregion + + + + //============// + // singletons // + //============// + //region + @Override public IDhMetaRenderer getMetaRenderer() { return OpenGlDhMetaRenderer.INSTANCE; } - @Override public IDhTerrainRenderer getTerrainRenderer() { return DhTerrainShaderProgram.INSTANCE; } // TODO how to support Iris? + @Override public IDhTerrainRenderer getTerrainRenderer() { return DhTerrainShaderProgram.INSTANCE; } @Override public IDhSsaoRenderer getSsaoRenderer() { return DhSSAORenderer.INSTANCE; } @Override public IDhFogRenderer getFogRenderer() { return DhFogRenderer.INSTANCE; } @Override public IDhFarFadeRenderer getFarFadeRenderer() { return DhFarFadeRenderer.INSTANCE; } @@ -31,13 +44,23 @@ public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return VanillaFadeRenderer.INSTANCE; } @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return GlTestTriangleRenderer.INSTANCE; } - @Override public IDhGenericRenderer createGenericRenderer() { return OpenGlGenericObjectRenderer.INSTANCE; } + //endregion + + //===========// + // factories // + //===========// + //region + + @Override public IDhGenericRenderer createGenericRenderer() { return OpenGlGenericObjectRenderer.INSTANCE; } + @Override public IVertexBufferWrapper createVboWrapper(String name) { return new GLVertexBuffer(); } @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new OpenGlDummyUniformData(); } @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new OpenGlGenericObjectVertexContainer(); } + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java index ff1369a46..3035e850d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java @@ -10,7 +10,6 @@ public class DhFramebuffer implements IDhApiFramebuffer { private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; - private final Int2IntMap attachments; private int id; @@ -18,27 +17,21 @@ public class DhFramebuffer implements IDhApiFramebuffer //=============// // constructor // //=============// + //region - public DhFramebuffer() - { - this.id = GL32.glGenFramebuffers(); - - this.attachments = new Int2IntArrayMap(); - } + public DhFramebuffer() { this.id = GL32.glGenFramebuffers(); } /** For internal use by Iris, do not remove. */ - public DhFramebuffer(int id) - { - this.id = id; - - this.attachments = new Int2IntArrayMap(); - } + public DhFramebuffer(int id) { this.id = id; } + + //endregion //=========// // methods // //=========// + //region @Override public void addDepthAttachment(int textureId, boolean isCombinedStencil) @@ -55,7 +48,6 @@ public class DhFramebuffer implements IDhApiFramebuffer this.bind(); GL32.glFramebufferTexture2D(GL32.GL_FRAMEBUFFER, GL32.GL_COLOR_ATTACHMENT0 + textureIndex, GL32.GL_TEXTURE_2D, textureId, 0); - this.attachments.put(textureIndex, textureId); } @Override @@ -86,12 +78,19 @@ public class DhFramebuffer implements IDhApiFramebuffer @Override public int getId() { return this.id; } + //endregion + //=============// // API methods // //=============// + //region public boolean overrideThisFrame() { return true; } + //endregion + + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java index dada9d870..791722449 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java @@ -19,22 +19,30 @@ package com.seibel.distanthorizons.common.wrappers; +import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; -/** - * @author James Seibel - * @version 12-11-2021 - */ public class VersionConstants implements IVersionConstants { public static final VersionConstants INSTANCE = new VersionConstants(); - private VersionConstants() - { - - } + //=============// + // constructor // + //=============// + //region + + private VersionConstants() { } + + //endregion + + + + //=========// + // methods // + //=========// + //region @Override public String getMinecraftVersion() @@ -91,4 +99,18 @@ public class VersionConstants implements IVersionConstants } + @Override + public EDhApiRenderApi getDefaultRenderer() + { + #if MC_VER <= MC_1_21_11 + return EDhApiRenderApi.OPEN_GL; + #else + ERROR MC version constant missing + #endif + } + + //endregion + + + } \ No newline at end of file diff --git a/coreSubProjects b/coreSubProjects index 0362d8917..5b0bf59f0 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 0362d89173523c21bf198e6a7481a8bb75d23290 +Subproject commit 5b0bf59f00d52b72a65e09459a2d6c31242fbc42 From a01a9ac3561f613ae9c3eb06de36d50799049594 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 16:59:19 -0500 Subject: [PATCH 54/72] Improve vertex attrib mod compatability --- .../common/AbstractModInitializer.java | 2 +- .../blaze/util/DhBlazeVertexFormatUtil.java | 91 +++++++++++++++++-- .../common/wrappers/VersionConstants.java | 2 +- coreSubProjects | 2 +- 4 files changed, 85 insertions(+), 12 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java index aba9025e4..6c5434815 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/AbstractModInitializer.java @@ -337,7 +337,7 @@ public abstract class AbstractModInitializer if (renderApi == EDhApiRenderApi.AUTO) { IVersionConstants versionConstants = SingletonInjector.INSTANCE.get(IVersionConstants.class); - renderApi = versionConstants.getDefaultRenderer(); + renderApi = versionConstants.getDefaultRenderingApi(); } // Iris only supports nataive OpenGL diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java index d4e34b0fb..6631f63ad 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java @@ -1,25 +1,98 @@ package com.seibel.distanthorizons.common.render.blaze.util; import com.mojang.blaze3d.vertex.VertexFormatElement; +import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; +import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; +import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.logging.DhLogger; +import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.wrapperInterfaces.IVersionConstants; +import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; /** * @see LodQuadBuilder */ public class DhBlazeVertexFormatUtil { - public static final VertexFormatElement SCREEN_POS = VertexFormatElement.register(/*id*/7, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); - public static final VertexFormatElement RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/8, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + private static final DhLogger LOGGER = new DhLoggerBuilder().build(); - public static final VertexFormatElement SHORT_XYZ_POS = VertexFormatElement.register(/*id*/9, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); - public static final VertexFormatElement BYTE_PAD = VertexFormatElement.register(/*id*/10, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + + + public static final VertexFormatElement SCREEN_POS; + public static final VertexFormatElement RGBA_FLOAT_COLOR; + + public static final VertexFormatElement SHORT_XYZ_POS; + public static final VertexFormatElement BYTE_PAD; /** contains light and micro-offset */ - public static final VertexFormatElement META = VertexFormatElement.register(/*id*/11, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.GENERIC, /*count*/ 1); - public static final VertexFormatElement RGBA_UBYTE_COLOR = VertexFormatElement.register(/*id*/12, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.COLOR, /*count*/ 4); - public static final VertexFormatElement IRIS_MATERIAL = VertexFormatElement.register(/*id*/13, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); - public static final VertexFormatElement IRIS_NORMAL = VertexFormatElement.register(/*id*/14, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + public static final VertexFormatElement META; + public static final VertexFormatElement RGBA_UBYTE_COLOR; + public static final VertexFormatElement IRIS_MATERIAL; + public static final VertexFormatElement IRIS_NORMAL; - public static final VertexFormatElement FLOAT_XYZ_POS = VertexFormatElement.register(/*id*/15, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + public static final VertexFormatElement FLOAT_XYZ_POS; + + + + + static + { + EDhApiRenderApi renderingApi = Config.Client.Advanced.Graphics.Experimental.renderingApi.get(); + if (renderingApi == EDhApiRenderApi.AUTO) + { + IVersionConstants versionConstants = SingletonInjector.INSTANCE.get(IVersionConstants.class); + renderingApi = versionConstants.getDefaultRenderingApi(); + } + + boolean register = (renderingApi == EDhApiRenderApi.BLAZE_3D); + if (register) + { + LOGGER.debug("Attempting to register ["+VertexFormatElement.class.getSimpleName()+"]..."); + + try + { + SCREEN_POS = VertexFormatElement.register(/*id*/22, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 2); + RGBA_FLOAT_COLOR = VertexFormatElement.register(/*id*/23, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.COLOR, /*count*/ 4); + + SHORT_XYZ_POS = VertexFormatElement.register(/*id*/24, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + BYTE_PAD = VertexFormatElement.register(/*id*/25, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + + META = VertexFormatElement.register(/*id*/26, /*index*/0, VertexFormatElement.Type.USHORT, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + RGBA_UBYTE_COLOR = VertexFormatElement.register(/*id*/27, /*index*/0, VertexFormatElement.Type.UBYTE, VertexFormatElement.Usage.COLOR, /*count*/ 4); + IRIS_MATERIAL = VertexFormatElement.register(/*id*/28, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + IRIS_NORMAL = VertexFormatElement.register(/*id*/29, /*index*/0, VertexFormatElement.Type.BYTE, VertexFormatElement.Usage.GENERIC, /*count*/ 1); + + FLOAT_XYZ_POS = VertexFormatElement.register(/*id*/30, /*index*/0, VertexFormatElement.Type.FLOAT, VertexFormatElement.Usage.POSITION, /*count*/ 3); + } + catch (Exception e) + { + String message = "Unable to register one or more ["+VertexFormatElement.class.getSimpleName()+"] this is likely caused by another mod registering their own custom ["+VertexFormatElement.class.getSimpleName()+"]'s. This should be fixed in the next major Minecraft version."; + + IMinecraftClientWrapper mc = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); + mc.crashMinecraft(message, new Exception(message, e)); + + // here to make the compiler happy, the process should shut down before this + throw new RuntimeException(e); + } + + LOGGER.debug("Successfully registered ["+VertexFormatElement.class.getSimpleName()+"]."); + } + else + { + SCREEN_POS = null; + RGBA_FLOAT_COLOR = null; + + SHORT_XYZ_POS = null; + BYTE_PAD = null; + + META = null; + RGBA_UBYTE_COLOR = null; + IRIS_MATERIAL = null; + IRIS_NORMAL = null; + + FLOAT_XYZ_POS = null; + } + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java index 791722449..1a6ff387e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/VersionConstants.java @@ -100,7 +100,7 @@ public class VersionConstants implements IVersionConstants } @Override - public EDhApiRenderApi getDefaultRenderer() + public EDhApiRenderApi getDefaultRenderingApi() { #if MC_VER <= MC_1_21_11 return EDhApiRenderApi.OPEN_GL; diff --git a/coreSubProjects b/coreSubProjects index 5b0bf59f0..9e7d0a153 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 5b0bf59f00d52b72a65e09459a2d6c31242fbc42 +Subproject commit 9e7d0a15386986c3cb172ecdb3f2c9aef98ecc04 From cf6945b44c7367a2a9b0cd79bff0e57c5fe793e0 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:03:39 -0500 Subject: [PATCH 55/72] finish a few comments --- .../common/render/blaze/BlazeDhTerrainRenderer.java | 7 ------- .../render/nativeGl/glObject/OpenGlDummyUniformData.java | 4 ++++ coreSubProjects | 2 +- 3 files changed, 5 insertions(+), 8 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index fef5fcf61..b32289618 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -14,35 +14,28 @@ import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; -import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.pos.DhSectionPos; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; import com.seibel.distanthorizons.core.render.RenderParams; -import com.seibel.distanthorizons.core.util.ColorUtil; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; -import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; import org.lwjgl.opengl.GL32; import org.lwjgl.system.MemoryUtil; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java index b7e1f5f6b..03df57f71 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java @@ -3,6 +3,10 @@ package com.seibel.distanthorizons.common.render.nativeGl.glObject; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; +/** + * With OpenGL all uniform data is uploaded during the rendering phase + * so nothing is needed here. + */ public class OpenGlDummyUniformData implements ILodContainerUniformBufferWrapper { @Override public void createUniformData(LodBufferContainer bufferContainer) { } diff --git a/coreSubProjects b/coreSubProjects index 9e7d0a153..b51ab3d9c 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 9e7d0a15386986c3cb172ecdb3f2c9aef98ecc04 +Subproject commit b51ab3d9cd5bfeb2b81beb884a6b9b25935444ce From dfee36f4163f6221becd28cfad7897fe5f1892c1 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:20:22 -0500 Subject: [PATCH 56/72] Make render interfaces consistent --- .../render/blaze/BlazeDhMetaRenderer.java | 2 +- .../postProcessing/BlazeDhFogRenderer.java | 9 ++-- .../postProcessing/BlazeDhSsaoRenderer.java | 7 +-- .../BlazeVanillaFadeRenderer.java | 13 ++--- .../test/BlazeDhTestTriangleRenderer.java | 4 +- .../render/nativeGl/OpenGlDhMetaRenderer.java | 2 +- .../postProcessing/apply/DhApplyShader.java | 3 -- .../fade/DhFarFadeApplyShader.java | 3 +- .../fade/DhFarFadeRenderer.java | 4 +- .../postProcessing/fade/DhFarFadeShader.java | 3 +- .../fade/VanillaFadeRenderer.java | 14 +++--- .../fade/VanillaFadeShader.java | 6 ++- .../postProcessing/fog/DhFogRenderer.java | 9 ++-- .../postProcessing/fog/FogApplyShader.java | 3 +- .../postProcessing/fog/FogShader.java | 19 ++++++-- .../postProcessing/ssao/DhSSAORenderer.java | 10 ++-- .../postProcessing/ssao/SSAOApplyShader.java | 3 +- .../postProcessing/ssao/SSAOShader.java | 3 +- .../nativeGl/test/GlTestTriangleRenderer.java | 6 ++- .../nativeGl/util/AbstractShaderRenderer.java | 47 ++++++++++++++++--- coreSubProjects | 2 +- 21 files changed, 116 insertions(+), 56 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java index 4c3f1ab86..71bf83451 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java @@ -56,7 +56,7 @@ public class BlazeDhMetaRenderer implements IDhMetaRenderer public void runRenderPassCleanup(RenderParams renderParams) {} @Override - public void applyToMcTexture() + public void applyToMcTexture(RenderParams renderParams) { GpuTexture mcColorTexture = Minecraft.getInstance().getMainRenderTarget().getColorTexture(); this.applyRenderer.render(this.dhColorTextureWrapper.texture, this.dhDepthTextureWrapper.texture, mcColorTexture); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index 850294197..deafa053d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -49,6 +49,7 @@ import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; @@ -150,7 +151,7 @@ public class BlazeDhFogRenderer implements IDhFogRenderer //region @Override - public void render(DhApiMat4f modelViewProjectionMatrix, float partialTicks) + public void render(RenderParams renderParams) { this.tryInit(); @@ -213,16 +214,16 @@ public class BlazeDhFogRenderer implements IDhFogRenderer int lodDrawDistance = Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius.get() * LodUtil.CHUNK_WIDTH; - Mat4f inverseMvmProjMatrix = new Mat4f(modelViewProjectionMatrix); + Mat4f inverseMvmProjMatrix = new Mat4f(renderParams.dhMvmProjMatrix); inverseMvmProjMatrix.invert(); - if (modelViewProjectionMatrix == null) + if (renderParams.dhMvmProjMatrix == null) { return; } - Color fogColor = this.getFogColor(partialTicks); + Color fogColor = this.getFogColor(renderParams.partialTicks); // fog config float farFogStart = Config.Client.Advanced.Graphics.Fog.farFogStart.get(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index 1cc172be7..e14aa588e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -45,6 +45,7 @@ import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -141,7 +142,7 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer //region @Override - public void render(DhApiMat4f dhProjectionMatrix) + public void render(RenderParams renderParams) { this.tryInit(); @@ -175,8 +176,8 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer // create data // - Mat4f projMatrix = new Mat4f(dhProjectionMatrix); - Mat4f invertedProjMatrix = new Mat4f(dhProjectionMatrix); + Mat4f projMatrix = new Mat4f(renderParams.dhProjectionMatrix); + Mat4f invertedProjMatrix = new Mat4f(renderParams.dhProjectionMatrix); invertedProjMatrix.invert(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index e064535b9..78533d213 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -43,6 +43,7 @@ import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -141,7 +142,7 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer //region @Override - public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) + public void render(RenderParams renderParams) { this.tryInit(); @@ -183,14 +184,14 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer float fadeEndDistance = dhNearClipDistance * 1.9f; - Mat4f inverseMcModelViewProjectionMatrix = new Mat4f(mcProjectionMatrix); - inverseMcModelViewProjectionMatrix.multiply(mcModelViewMatrix); + Mat4f inverseMcModelViewProjectionMatrix = new Mat4f(renderParams.mcProjectionMatrix); + inverseMcModelViewProjectionMatrix.multiply(renderParams.mcModelViewMatrix); inverseMcModelViewProjectionMatrix.invert(); Mat4f inverseMcMvmProjMatrix = inverseMcModelViewProjectionMatrix; - Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(mcProjectionMatrix); - Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(mcModelViewMatrix); + Mat4f dhProjectionMatrix = RenderUtil.createLodProjectionMatrix(renderParams.mcProjectionMatrix); + Mat4f dhModelViewMatrix = RenderUtil.createLodModelViewMatrix(renderParams.mcModelViewMatrix); Mat4f inverseDhModelViewProjectionMatrix = new Mat4f(dhProjectionMatrix); inverseDhModelViewProjectionMatrix.multiply(dhModelViewMatrix); @@ -207,7 +208,7 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer .putInt(Config.Client.Advanced.Debugging.lodOnlyMode.get() ? 1 : 0) // uOnlyRenderLods .putFloat(fadeStartDistance) // uStartFadeBlockDistance .putFloat(fadeEndDistance) // uEndFadeBlockDistance - .putFloat(level.getMaxHeight()) // uMaxLevelHeight + .putFloat(renderParams.clientLevelWrapper.getMaxHeight()) // uMaxLevelHeight .putMat4f(inverseDhMvmProjMatrix.createJomlMatrix()) // uDhInvMvmProj .putMat4f(inverseMcMvmProjMatrix.createJomlMatrix()) // uMcInvMvmProj .get() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java index 697b7288e..d832cf964 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java @@ -33,6 +33,7 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -159,7 +160,8 @@ public class BlazeDhTestTriangleRenderer implements IDhTestTriangleRenderer //========// //region - public void render() + @Override + public void render(RenderParams renderParams) { this.tryInit(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java index 579f73b44..cf6c25a55 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java @@ -364,7 +364,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer } @Override - public void applyToMcTexture() { DhApplyShader.INSTANCE.render(0.0f); } + public void applyToMcTexture(RenderParams renderParams) { DhApplyShader.INSTANCE.render(renderParams); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java index 84b8b3b8d..67a14ff8a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java @@ -69,9 +69,6 @@ public class DhApplyShader extends AbstractShaderRenderer } - @Override - protected void onApplyUniforms(float partialTicks) { } - //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java index d93e33dd0..9dfb15879 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java @@ -23,6 +23,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import org.lwjgl.opengl.GL32; /** @@ -75,7 +76,7 @@ public class DhFarFadeApplyShader extends AbstractShaderRenderer //=============// @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); GLMC.glBindTexture(this.fadeTexture); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java index e09fa92b3..cb3800aa8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java @@ -140,14 +140,14 @@ public class DhFarFadeRenderer implements IDhFarFadeRenderer DhFarFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; DhFarFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); - DhFarFadeShader.INSTANCE.render(0.0f); + DhFarFadeShader.INSTANCE.render(renderParams); //profiler.popPush("Fade Apply"); DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; DhFarFadeApplyShader.INSTANCE.drawFramebuffer = OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); - DhFarFadeApplyShader.INSTANCE.render(0.0f); + DhFarFadeApplyShader.INSTANCE.render(renderParams); } catch (Exception e) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java index 24944b228..e3d854937 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java @@ -27,6 +27,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQu import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -96,7 +97,7 @@ public class DhFarFadeShader extends AbstractShaderRenderer //=============// @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { this.shader.setUniform(this.uDhInvMvmProj, this.inverseDhMvmProjMatrix); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java index f26b0b7cb..057a0b599 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java @@ -19,18 +19,16 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhVanillaFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import org.lwjgl.opengl.GL32; @@ -124,7 +122,7 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer //region @Override - public void render(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix, IClientLevelWrapper level) + public void render(RenderParams renderParams) { int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); if (depthTextureId == -1) @@ -159,9 +157,9 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer VanillaFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; - VanillaFadeShader.INSTANCE.setProjectionMatrix(mcModelViewMatrix, mcProjectionMatrix); - VanillaFadeShader.INSTANCE.setLevelMaxHeight(level.getMaxHeight()); - VanillaFadeShader.INSTANCE.render(0); + VanillaFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); + VanillaFadeShader.INSTANCE.setLevelMaxHeight(renderParams.clientLevelWrapper.getMaxHeight()); + VanillaFadeShader.INSTANCE.render(renderParams); // Applying the fade texture is only needed if MC is drawing to their own frame buffer, // otherwise we can directly render to their texture @@ -172,7 +170,7 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; DhFarFadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); - DhFarFadeApplyShader.INSTANCE.render(0); + DhFarFadeApplyShader.INSTANCE.render(renderParams); } profiler.pop(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java index 354affe93..bd4ea32db 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java @@ -19,6 +19,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; @@ -27,6 +28,7 @@ import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -111,7 +113,7 @@ public class VanillaFadeShader extends AbstractShaderRenderer //region @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { this.shader.setUniform(this.uMcInvMvmProj, this.inverseMcMvmProjMatrix); this.shader.setUniform(this.uDhInvMvmProj, this.inverseDhMvmProjMatrix); @@ -135,7 +137,7 @@ public class VanillaFadeShader extends AbstractShaderRenderer this.shader.setUniform(this.uOnlyRenderLods, Config.Client.Advanced.Debugging.lodOnlyMode.get()); } - public void setProjectionMatrix(Mat4f mcModelViewMatrix, Mat4f mcProjectionMatrix) + public void setProjectionMatrix(DhApiMat4f mcModelViewMatrix, DhApiMat4f mcProjectionMatrix) { Mat4f inverseMcModelViewProjectionMatrix = new Mat4f(mcProjectionMatrix); inverseMcModelViewProjectionMatrix.multiply(mcModelViewMatrix); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java index 24ad5d80c..03dac4501 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java @@ -23,6 +23,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhFogRenderer; import org.lwjgl.opengl.GL32; @@ -108,7 +109,7 @@ public class DhFogRenderer implements IDhFogRenderer //region @Override - public void render(DhApiMat4f modelViewProjectionMatrix, float partialTicks) + public void render(RenderParams renderParams) { // GLState needed in MC 1.16.5 probably due to MC not manually setting each GL state they need before the next rendering step try (GLState state = new GLState()) @@ -126,11 +127,11 @@ public class DhFogRenderer implements IDhFogRenderer } FogShader.INSTANCE.frameBuffer = this.fogFramebuffer; - FogShader.INSTANCE.setProjectionMatrix(modelViewProjectionMatrix); - FogShader.INSTANCE.render(partialTicks); + FogShader.INSTANCE.setProjectionMatrix(renderParams.dhMvmProjMatrix); + FogShader.INSTANCE.render(renderParams); FogApplyShader.INSTANCE.fogTexture = this.fogTexture; - FogApplyShader.INSTANCE.render(partialTicks); + FogApplyShader.INSTANCE.render(renderParams); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java index 13f8f7177..e1f6c8308 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java @@ -25,6 +25,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import org.lwjgl.opengl.GL32; /** @@ -75,7 +76,7 @@ public class FogApplyShader extends AbstractShaderRenderer //=============// @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); GLMC.glBindTexture(this.fogTexture); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java index f81a921b6..7bc413807 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java @@ -31,6 +31,7 @@ import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -50,7 +51,6 @@ public class FogShader extends AbstractShaderRenderer public int frameBuffer; - private Mat4f inverseMvmProjMatrix; @@ -58,6 +58,7 @@ public class FogShader extends AbstractShaderRenderer //==========// // Uniforms // //==========// + //region public int uDepthMap; /** Inverted Model View Projection matrix */ @@ -94,11 +95,14 @@ public class FogShader extends AbstractShaderRenderer public int uHeightFogMixingMode; public int uCameraBlockYPos; + //endregion + //=============// // constructor // //=============// + //region public FogShader() { } @@ -150,14 +154,17 @@ public class FogShader extends AbstractShaderRenderer } + //endregion + //=============// // render prep // //=============// + //region @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { int lodDrawDistance = Config.Client.Advanced.Graphics.Quality.lodChunkRenderDistanceRadius.get() * LodUtil.CHUNK_WIDTH; @@ -170,7 +177,7 @@ public class FogShader extends AbstractShaderRenderer // Fog uniforms - this.shader.setUniform(this.uFogColor, this.getFogColor(partialTicks)); + this.shader.setUniform(this.uFogColor, this.getFogColor(renderParams.partialTicks)); this.shader.setUniform(this.uFogScale, 1.f / lodDrawDistance); this.shader.setUniform(this.uFogVerticalScale, 1.f / MC.getWrappedClientLevel().getMaxHeight()); // only used for debugging @@ -252,11 +259,14 @@ public class FogShader extends AbstractShaderRenderer this.inverseMvmProjMatrix.invert(); } + //endregion + //========// // render // //========// + //region @Override protected void onRender() @@ -286,4 +296,7 @@ public class FogShader extends AbstractShaderRenderer ScreenQuad.INSTANCE.render(); } + //endregion + + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java index 5110cf894..d53f94ede 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java @@ -23,6 +23,7 @@ import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhSsaoRenderer; import org.lwjgl.opengl.GL32; @@ -108,7 +109,8 @@ public class DhSSAORenderer implements IDhSsaoRenderer //========// //region - public void render(DhApiMat4f dhProjectionMatrix) + @Override + public void render(RenderParams renderParams) { try(GLState state = new GLState()) { @@ -125,11 +127,11 @@ public class DhSSAORenderer implements IDhSsaoRenderer } SSAOShader.INSTANCE.frameBuffer = this.ssaoFramebuffer; - SSAOShader.INSTANCE.setProjectionMatrix(dhProjectionMatrix); - SSAOShader.INSTANCE.render(0.0f); + SSAOShader.INSTANCE.setProjectionMatrix(renderParams.dhProjectionMatrix); + SSAOShader.INSTANCE.render(renderParams); SSAOApplyShader.INSTANCE.ssaoTexture = this.ssaoTexture; - SSAOApplyShader.INSTANCE.render(0.0f); + SSAOApplyShader.INSTANCE.render(renderParams); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java index 9a23a5194..ac49b12ca 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java @@ -25,6 +25,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import org.lwjgl.opengl.GL32; @@ -83,7 +84,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer //=============// @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java index c09e8da3c..68111f7b2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java @@ -26,6 +26,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderP import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.math.Mat4f; import org.lwjgl.opengl.GL32; @@ -102,7 +103,7 @@ public class SSAOShader extends AbstractShaderRenderer } @Override - protected void onApplyUniforms(float partialTicks) + protected void onApplyUniforms(RenderParams renderParams) { this.shader.setUniform(this.uProj, this.projection); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java index 6f9518dd5..dc7334285 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java @@ -29,6 +29,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVerte import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTestTriangleRenderer; @@ -122,7 +123,8 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer //========// //region - public void render() + @Override + public void render(RenderParams renderParams) { this.init(); @@ -134,7 +136,7 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 3); - DhApplyShader.INSTANCE.render(0.0f); + DhApplyShader.INSTANCE.render(renderParams); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java index 92e4a1e68..9a48970d9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.render.nativeGl.util; import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; +import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; @@ -30,10 +31,14 @@ public abstract class AbstractShaderRenderer protected ShaderProgram shader; - protected boolean init = false; + //=======// + // setup // + //=======// + //region + protected AbstractShaderRenderer() {} public void init() @@ -44,13 +49,36 @@ public abstract class AbstractShaderRenderer this.onInit(); } - public void render(float partialTicks) + //endregion + + + //==================// + // abstract methods // + //==================// + //region + + protected void onInit() {} + + protected void onApplyUniforms(RenderParams renderParams) {} + + protected void onRender() {} + + //endregion + + + + //===========// + // rendering // + //===========// + //region + + public void render(RenderParams renderParams) { this.init(); this.shader.bind(); - this.onApplyUniforms(partialTicks); + this.onApplyUniforms(renderParams); int width = MC_RENDER.getTargetFramebufferViewportWidth(); int height = MC_RENDER.getTargetFramebufferViewportHeight(); @@ -61,6 +89,14 @@ public abstract class AbstractShaderRenderer this.shader.unbind(); } + //endregion + + + //================// + // base overrides // + //================// + //region + public void free() { if (this.shader != null) @@ -69,9 +105,8 @@ public abstract class AbstractShaderRenderer } } - protected void onInit() {} + // endregion + - protected void onApplyUniforms(float partialTicks) {} - protected void onRender() {} } diff --git a/coreSubProjects b/coreSubProjects index b51ab3d9c..4e908b5b1 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit b51ab3d9cd5bfeb2b81beb884a6b9b25935444ce +Subproject commit 4e908b5b156e338f18589d20574ddc654d1bea97 From 7fed4b1ddb57120e0e0c7d487521192bbec18224 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:24:01 -0500 Subject: [PATCH 57/72] add missing comment --- .../blaze/wrappers/buffer/BlazeVertexBufferWrapper.java | 3 ++- .../common/render/nativeGl/DhTerrainShaderProgram.java | 5 ++++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java index aaf792df3..cfe982fcd 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java @@ -45,7 +45,8 @@ public class BlazeVertexBufferWrapper implements IVertexBufferWrapper public void upload(ByteBuffer buffer, int vertexCount) { this.vertexCount = vertexCount; - this.indexCount = (int)(vertexCount * 1.5); // TODO why multiply by 1.5? + // 4 vertices per face, but 6 indices (IE 2 triangles) per face, aka need to multiply by 1.5 + this.indexCount = (int)(vertexCount * 1.5); this.uploaded = true; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java index b150f5593..264b54cd5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -351,11 +351,14 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade continue; } + // 4 vertices per face, but 6 indices (IE 2 triangles) per face, aka need to multiply by 1.5 + int indexCount = (int)(vbo.getVertexCount() * 1.5); + vbo.bind(); OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bindVertexBuffer(vbo.getId()); GL32.glDrawElements( GL32.GL_TRIANGLES, - (int)(vbo.getVertexCount() * 1.5), + indexCount, this.quadIBO.getType(), 0); vbo.unbind(); } From c6c94ef906ef83e21fbfd74db0be45173db59b55 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:26:23 -0500 Subject: [PATCH 58/72] fix buffer render event for Blaze3D --- .../render/blaze/BlazeDhTerrainRenderer.java | 14 +++++++++++++- .../render/nativeGl/DhTerrainShaderProgram.java | 2 +- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index b32289618..1ae996b42 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -15,6 +15,7 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; +import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeBufferRenderEvent; import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; @@ -32,10 +33,13 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadEle import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; +import com.seibel.distanthorizons.core.util.math.Vec3d; +import com.seibel.distanthorizons.core.util.math.Vec3f; import com.seibel.distanthorizons.core.util.objects.SortedArraySet; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IProfilerWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhTerrainRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; import net.minecraft.resources.Identifier; import org.lwjgl.opengl.GL32; import org.lwjgl.system.MemoryUtil; @@ -347,7 +351,15 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer continue; } - //ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + // fire render event + { + Vec3d camPos = renderEventParam.exactCameraPosition; + Vec3f modelPos = new Vec3f( + (float) (bufferContainer.minCornerBlockPos.getX() - camPos.x), + (float) (bufferContainer.minCornerBlockPos.getY() - camPos.y), + (float) (bufferContainer.minCornerBlockPos.getZ() - camPos.z)); + ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); + } renderPass.setVertexBuffer(0, bufferWrapper.vboGpuBuffer); // vertex buffer can only be "0" lol diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java index 264b54cd5..c9bd18b01 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java @@ -323,7 +323,7 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade { LodBufferContainer bufferContainer = bufferContainers.get(lodIndex); - // set uniforms + // set uniforms and fire events { Vec3d camPos = renderEventParam.exactCameraPosition; Vec3f modelPos = new Vec3f( From ba977a29f0636ea142a5294799c0dfd3fcf08211 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:33:58 -0500 Subject: [PATCH 59/72] Move lightmap wrapper methods into common --- .../render/nativeGl/OpenGlDhMetaRenderer.java | 26 +++++++++++++++++-- .../common/wrappers/misc/LightMapWrapper.java | 10 +------ coreSubProjects | 2 +- 3 files changed, 26 insertions(+), 12 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java index cf6c25a55..8e7c26b33 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java @@ -11,6 +11,7 @@ import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadEle import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; +import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -19,6 +20,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.DhApiRenderProxy; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.modAccessor.AbstractOptifineAccessor; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhMetaRenderer; import com.seibel.distanthorizons.coreapi.DependencyInjection.ApiEventInjector; @@ -104,7 +106,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer this.setGLState(renderParams, firstPass); DhTerrainShaderProgram.INSTANCE.quadIBO.bind(); - renderParams.lightmap.bind(); + this.bindLightmap(renderParams.lightmap); } private void setGLState( DhApiRenderParam renderEventParam, @@ -358,7 +360,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer } - renderParams.lightmap.unbind(); + this.unbindLightmap(); DhTerrainShaderProgram.INSTANCE.quadIBO.unbind(); this.shaderProgramForThisFrame.unbind(); } @@ -447,5 +449,25 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer //endregion + //================// + // helper methods // + //================// + //region + + public void bindLightmap(ILightMapWrapper lightMapWrapper) + { + LightMapWrapper lightMap = (LightMapWrapper)lightMapWrapper; + GLMC.glActiveTexture(GL32.GL_TEXTURE0 + LightMapWrapper.GL_BOUND_INDEX); + GLMC.glBindTexture(lightMap.getOpenGlId()); + } + + public void unbindLightmap() + { + // strange that we don't call "glActiveTexture" here but since it's working James isn't going to change it right now (2026-03-10) + GLMC.glBindTexture(0); + } + + //endregion + } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 286fbe03b..5bee728d6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -126,15 +126,7 @@ public class LightMapWrapper implements ILightMapWrapper public BlazeTextureViewWrapper getTextureViewWrapper() { return this.lightmapTextureWrapper; } - @Override - public void bind() - { - GLMC.glActiveTexture(GL32.GL_TEXTURE0 + LightMapWrapper.GL_BOUND_INDEX); - GLMC.glBindTexture(this.textureId); - } - - @Override - public void unbind() { GLMC.glBindTexture(0); } + public int getOpenGlId() { return this.textureId; } //endregion diff --git a/coreSubProjects b/coreSubProjects index 4e908b5b1..e426fc238 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 4e908b5b156e338f18589d20574ddc654d1bea97 +Subproject commit e426fc238022d8f4c584e6ff6d505a62564ebcab From 9e5be3ad21585f0502b3f1f776e62dbf35a1af50 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:42:14 -0500 Subject: [PATCH 60/72] prefix all blaze/openGl objects --- .../blaze/BlazeDebugWireframeRenderer.java | 8 +- .../blaze/BlazeDhGenericObjectRenderer.java | 14 +- .../blaze/BlazeDhRenderApiDefinition.java | 3 +- .../render/blaze/BlazeDhTerrainRenderer.java | 28 ++-- .../blaze/apply/BlazeDhApplyRenderer.java | 4 +- .../BlazeGenericObjectVertexContainer.java | 4 +- .../BlazeDhFarFadeRenderer.java | 5 +- .../postProcessing/BlazeDhFogRenderer.java | 6 +- .../postProcessing/BlazeDhSsaoRenderer.java | 8 +- .../BlazeVanillaFadeRenderer.java | 6 +- .../test/BlazeDhTestTriangleRenderer.java | 6 +- ...Util.java => BlazeDhVertexFormatUtil.java} | 2 +- .../blaze/util/BlazePostProcessUtil.java | 2 +- .../BlazeUniformUtil.java} | 5 +- .../uniform/BlazeLodUniformBufferWrapper.java | 2 +- ...er.java => BlazeUniformBufferWrapper.java} | 4 +- .../nativeGl/OpenGlDhRenderApiDefinition.java | 66 --------- .../texture/EDhInternalTextureFormat.java | 130 ----------------- .../nativeGl/glObject/texture/EGlVersion.java | 9 -- .../vertexAttribute/VertexPointer.java | 72 ---------- .../postProcessing/fog/FogSettings.java | 72 ---------- .../GlDhDebugWireframeRenderer.java} | 26 ++-- .../GlDhMetaRenderer.java} | 53 +++---- .../openGl/GlDhRenderApiDefinition.java | 66 +++++++++ .../GlDhTerrainShaderProgram.java} | 50 +++---- .../generic/GlGenericObjectRenderer.java} | 22 +-- .../GlGenericObjectShaderProgram.java} | 19 ++- .../GlGenericObjectVertexContainer.java} | 6 +- .../glObject/GLProxy.java | 6 +- .../glObject/GLState.java | 4 +- .../glObject/GlDhFramebuffer.java} | 10 +- .../glObject/GlDummyUniformData.java} | 4 +- .../glObject/buffer/GLBuffer.java | 5 +- .../glObject/buffer/GLElementBuffer.java | 2 +- .../glObject/buffer/GLVertexBuffer.java | 4 +- .../glObject/buffer/GlQuadElementBuffer.java} | 8 +- .../openGl/glObject/enums/EGlVersion.java | 9 ++ .../glObject/enums}/GLEnums.java | 2 +- .../glObject/shader/GlShader.java} | 8 +- .../glObject/shader/GlShaderProgram.java} | 30 ++-- .../texture/EGlDhDepthBufferFormat.java} | 30 ++-- .../texture/EGlDhInternalTextureFormat.java | 131 ++++++++++++++++++ .../glObject/texture/EGlDhPixelFormat.java} | 11 +- .../glObject/texture/EGlDhPixelType.java} | 11 +- .../glObject/texture/GlDhColorTexture.java} | 28 ++-- .../glObject/texture/GlDhDepthTexture.java} | 10 +- .../GlAbstractVertexAttribute.java} | 20 +-- .../GlVertexAttributePostGL43.java} | 10 +- .../GlVertexAttributePreGL43.java} | 24 ++-- .../vertexAttribute/GlVertexPointer.java | 72 ++++++++++ .../postProcessing/GlScreenQuad.java} | 20 +-- .../apply/GlDhApplyShader.java} | 35 +++-- .../fade/GlDhFarFadeApplyShader.java} | 20 +-- .../fade/GlDhFarFadeRenderer.java} | 35 +++-- .../fade/GlDhFarFadeShader.java} | 25 ++-- .../fade/GlDhVanillaFadeShader.java} | 25 ++-- .../fade/GlVanillaFadeRenderer.java} | 44 +++--- .../fog/GlDhFogApplyShader.java} | 29 ++-- .../postProcessing/fog/GlDhFogRenderer.java} | 35 +++-- .../postProcessing/fog/GlDhFogShader.java} | 23 ++- .../ssao/GlDhSSAOApplyShader.java} | 29 ++-- .../ssao/GlDhSSAORenderer.java} | 35 +++-- .../postProcessing/ssao/GlDhSSAOShader.java} | 25 ++-- .../test/GlTestTriangleRenderer.java | 26 ++-- .../util/GlAbstractShaderRenderer.java} | 10 +- .../util/vertexFormat/GlLodVertexFormat.java} | 16 +-- .../GlLodVertexFormatElement.java} | 12 +- .../util/vertexFormat/GlVertexFormats.java} | 18 +-- .../common/wrappers/DependencySetup.java | 4 +- .../minecraft/MinecraftClientWrapper.java | 1 - 70 files changed, 754 insertions(+), 850 deletions(-) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers => objects}/BlazeGenericObjectVertexContainer.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/{DhBlazeVertexFormatUtil.java => BlazeDhVertexFormatUtil.java} (99%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/{helpers/UniformHandler.java => util/BlazeUniformUtil.java} (85%) rename common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/{UniformBufferWrapper.java => BlazeUniformBufferWrapper.java} (95%) delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java delete mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/OpenGlDebugWireframeRenderer.java => openGl/GlDhDebugWireframeRenderer.java} (83%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/OpenGlDhMetaRenderer.java => openGl/GlDhMetaRenderer.java} (88%) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhRenderApiDefinition.java rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/DhTerrainShaderProgram.java => openGl/GlDhTerrainShaderProgram.java} (84%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/generic/OpenGlGenericObjectRenderer.java => openGl/generic/GlGenericObjectRenderer.java} (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/generic/GenericObjectShaderProgram.java => openGl/generic/GlGenericObjectShaderProgram.java} (91%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/generic/OpenGlGenericObjectVertexContainer.java => openGl/generic/GlGenericObjectVertexContainer.java} (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/glObject/GLProxy.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/glObject/GLState.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/DhFramebuffer.java => openGl/glObject/GlDhFramebuffer.java} (83%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/OpenGlDummyUniformData.java => openGl/glObject/GlDummyUniformData.java} (77%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/glObject/buffer/GLBuffer.java (97%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/glObject/buffer/GLElementBuffer.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/glObject/buffer/GLVertexBuffer.java (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/buffer/QuadElementBuffer.java => openGl/glObject/buffer/GlQuadElementBuffer.java} (94%) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/EGlVersion.java rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject => openGl/glObject/enums}/GLEnums.java (98%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/shader/Shader.java => openGl/glObject/shader/GlShader.java} (95%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/shader/ShaderProgram.java => openGl/glObject/shader/GlShaderProgram.java} (86%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/EDhDepthBufferFormat.java => openGl/glObject/texture/EGlDhDepthBufferFormat.java} (71%) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhInternalTextureFormat.java rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/EDhPixelFormat.java => openGl/glObject/texture/EGlDhPixelFormat.java} (76%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/EDhPixelType.java => openGl/glObject/texture/EGlDhPixelType.java} (82%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/DhColorTexture.java => openGl/glObject/texture/GlDhColorTexture.java} (82%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/texture/DHDepthTexture.java => openGl/glObject/texture/GlDhDepthTexture.java} (83%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java => openGl/glObject/vertexAttribute/GlAbstractVertexAttribute.java} (83%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java => openGl/glObject/vertexAttribute/GlVertexAttributePostGL43.java} (93%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java => openGl/glObject/vertexAttribute/GlVertexAttributePreGL43.java} (90%) create mode 100644 common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexPointer.java rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/ScreenQuad.java => openGl/postProcessing/GlScreenQuad.java} (78%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/apply/DhApplyShader.java => openGl/postProcessing/apply/GlDhApplyShader.java} (79%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fade/DhFarFadeApplyShader.java => openGl/postProcessing/fade/GlDhFarFadeApplyShader.java} (79%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fade/DhFarFadeRenderer.java => openGl/postProcessing/fade/GlDhFarFadeRenderer.java} (75%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fade/DhFarFadeShader.java => openGl/postProcessing/fade/GlDhFarFadeShader.java} (84%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fade/VanillaFadeShader.java => openGl/postProcessing/fade/GlDhVanillaFadeShader.java} (88%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fade/VanillaFadeRenderer.java => openGl/postProcessing/fade/GlVanillaFadeRenderer.java} (76%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fog/FogApplyShader.java => openGl/postProcessing/fog/GlDhFogApplyShader.java} (72%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fog/DhFogRenderer.java => openGl/postProcessing/fog/GlDhFogRenderer.java} (79%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/fog/FogShader.java => openGl/postProcessing/fog/GlDhFogShader.java} (93%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/ssao/SSAOApplyShader.java => openGl/postProcessing/ssao/GlDhSSAOApplyShader.java} (77%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/ssao/DhSSAORenderer.java => openGl/postProcessing/ssao/GlDhSSAORenderer.java} (78%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/postProcessing/ssao/SSAOShader.java => openGl/postProcessing/ssao/GlDhSSAOShader.java} (80%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl => openGl}/test/GlTestTriangleRenderer.java (79%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/util/AbstractShaderRenderer.java => openGl/util/GlAbstractShaderRenderer.java} (89%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/util/vertexFormat/LodVertexFormat.java => openGl/util/vertexFormat/GlLodVertexFormat.java} (79%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/util/vertexFormat/LodVertexFormatElement.java => openGl/util/vertexFormat/GlLodVertexFormatElement.java} (87%) rename common/src/main/java/com/seibel/distanthorizons/common/render/{nativeGl/util/vertexFormat/VertexFormats.java => openGl/util/vertexFormat/GlVertexFormats.java} (50%) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index 286c7f818..a1db1eb56 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -32,8 +32,8 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeDhVertexFormatUtil; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -135,7 +135,7 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer private void createPipelines() { VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) + .add("vPosition", BlazeDhVertexFormatUtil.FLOAT_XYZ_POS) .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); @@ -283,7 +283,7 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer .get() ; - this.uniformBuffer = UniformHandler.createBuffer("uniformBlock", uniformBufferSize, this.uniformBuffer); + this.uniformBuffer = BlazeUniformUtil.createBuffer("uniformBlock", uniformBufferSize, this.uniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.uniformBuffer, 0, uniformBufferSize); commandEncoder.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index c8183fa58..05859dfec 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -42,10 +42,10 @@ import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeG import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.objects.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeDhVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; -import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -128,9 +128,9 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer this.init = true; this.vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.FLOAT_XYZ_POS) - .add("aColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) - .add("aMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) + .add("vPosition", BlazeDhVertexFormatUtil.FLOAT_XYZ_POS) + .add("aColor", BlazeDhVertexFormatUtil.RGBA_UBYTE_COLOR) + .add("aMaterial", BlazeDhVertexFormatUtil.IRIS_MATERIAL) .build(); this.createPipelines(); @@ -480,7 +480,7 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer .get() ; - this.vertUniformBuffer = UniformHandler.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); + this.vertUniformBuffer = BlazeUniformUtil.createBuffer("vertUniformBlock", uniformBufferSize, this.vertUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java index de117e308..f91eb3c32 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -1,6 +1,6 @@ package com.seibel.distanthorizons.common.render.blaze; -import com.seibel.distanthorizons.common.render.blaze.helpers.BlazeGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.blaze.objects.BlazeGenericObjectVertexContainer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhSsaoRenderer; @@ -8,7 +8,6 @@ import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeVanill import com.seibel.distanthorizons.common.render.blaze.test.BlazeDhTestTriangleRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index 1ae996b42..11b3845dd 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -16,8 +16,8 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeBufferRenderEvent; -import com.seibel.distanthorizons.common.render.blaze.helpers.*; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeDhVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.uniform.BlazeLodUniformBufferWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.buffer.BlazeVertexBufferWrapper; @@ -28,8 +28,8 @@ import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuad import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.pos.DhSectionPos; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.GLEnums; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GlQuadElementBuffer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; @@ -88,13 +88,13 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SHORT_XYZ_POS) - .add("meta", DhBlazeVertexFormatUtil.META) - .add("vColor", DhBlazeVertexFormatUtil.RGBA_UBYTE_COLOR) - .add("irisMaterial", DhBlazeVertexFormatUtil.IRIS_MATERIAL) - .add("irisNormal", DhBlazeVertexFormatUtil.IRIS_NORMAL) - .add("paddingTwo", DhBlazeVertexFormatUtil.BYTE_PAD) - .add("paddingThree", DhBlazeVertexFormatUtil.BYTE_PAD) // padding is to make sure the format is a multiple of 4 + .add("vPosition", BlazeDhVertexFormatUtil.SHORT_XYZ_POS) + .add("meta", BlazeDhVertexFormatUtil.META) + .add("vColor", BlazeDhVertexFormatUtil.RGBA_UBYTE_COLOR) + .add("irisMaterial", BlazeDhVertexFormatUtil.IRIS_MATERIAL) + .add("irisNormal", BlazeDhVertexFormatUtil.IRIS_NORMAL) + .add("paddingTwo", BlazeDhVertexFormatUtil.BYTE_PAD) + .add("paddingThree", BlazeDhVertexFormatUtil.BYTE_PAD) // padding is to make sure the format is a multiple of 4 .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); @@ -207,7 +207,7 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer .putMat4f(combinedMatrix.createJomlMatrix()) // uCombinedMatrix .get(); - this.vertSharedUniformBuffer = UniformHandler.createBuffer("vertSharedUniformBlock", uniformBufferSize, this.vertSharedUniformBuffer); + this.vertSharedUniformBuffer = BlazeUniformUtil.createBuffer("vertSharedUniformBlock", uniformBufferSize, this.vertSharedUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.vertSharedUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); @@ -249,7 +249,7 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer .get() ; - this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = BlazeUniformUtil.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); @@ -260,7 +260,7 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer if (this.indexBuffer == null) { ByteBuffer buffer = MemoryUtil.memAlloc(LodQuadBuilder.getMaxBufferByteSize() * GLEnums.getTypeSize(GL32.GL_UNSIGNED_INT) * 6); - QuadElementBuffer.buildBuffer(LodQuadBuilder.getMaxBufferByteSize(), buffer, GL32.GL_UNSIGNED_INT); + GlQuadElementBuffer.buildBuffer(LodQuadBuilder.getMaxBufferByteSize(), buffer, GL32.GL_UNSIGNED_INT); // create buffer if needed diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java index 2539c2cf1..636716246 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java @@ -31,7 +31,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeDhVertexFormatUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -146,7 +146,7 @@ public class BlazeDhApplyRenderer } VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) + .add("vPosition", BlazeDhVertexFormatUtil.SCREEN_POS) .build(); RenderPipeline.Builder pipelineBuilder = RenderPipeline.builder(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java index f9c3f467f..b6fe50565 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.objects; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -8,7 +8,7 @@ import com.mojang.blaze3d.systems.RenderSystem; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.GLEnums; import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; import com.seibel.distanthorizons.core.render.renderer.RenderableBoxGroup; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index 2eeb400aa..9f01b56c4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -33,10 +33,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -184,7 +183,7 @@ public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer .get() ; - this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = BlazeUniformUtil.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index deafa053d..8a2b3c81c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -38,13 +38,11 @@ import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; -import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -302,7 +300,7 @@ public class BlazeDhFogRenderer implements IDhFogRenderer .get() ; - this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = BlazeUniformUtil.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index e14aa588e..f9de81aa8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -35,13 +35,11 @@ import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; -import com.seibel.distanthorizons.common.render.blaze.helpers.UniformHandler; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -199,7 +197,7 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer .get() ; - this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = BlazeUniformUtil.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); @@ -236,7 +234,7 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer .get() ; - this.applyFragUniformBuffer = UniformHandler.createBuffer("applyFragUniformBlock", uniformBufferSize, this.applyFragUniformBuffer); + this.applyFragUniformBuffer = BlazeUniformUtil.createBuffer("applyFragUniformBlock", uniformBufferSize, this.applyFragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.applyFragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index 78533d213..788fd1538 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -33,10 +33,9 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.vertex.VertexFormat; import com.seibel.distanthorizons.common.render.blaze.BlazeDhMetaRenderer; -import com.seibel.distanthorizons.common.render.blaze.BlazeDhTerrainRenderer; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhCopyRenderer; -import com.seibel.distanthorizons.common.render.blaze.helpers.*; import com.seibel.distanthorizons.common.render.blaze.util.BlazePostProcessUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeUniformUtil; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -48,7 +47,6 @@ import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.IDhVanillaFadeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import net.minecraft.client.Minecraft; import net.minecraft.resources.Identifier; @@ -214,7 +212,7 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer .get() ; - this.fragUniformBuffer = UniformHandler.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); + this.fragUniformBuffer = BlazeUniformUtil.createBuffer("fragUniformBlock", uniformBufferSize, this.fragUniformBuffer); GpuBufferSlice bufferSlice = new GpuBufferSlice(this.fragUniformBuffer, 0, uniformBufferSize); COMMAND_ENCODER.writeToBuffer(bufferSlice, buffer); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java index d832cf964..563b82853 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java @@ -30,7 +30,7 @@ import com.mojang.blaze3d.systems.RenderPass; import com.mojang.blaze3d.systems.RenderSystem; import com.mojang.blaze3d.textures.*; import com.mojang.blaze3d.vertex.VertexFormat; -import com.seibel.distanthorizons.common.render.blaze.util.DhBlazeVertexFormatUtil; +import com.seibel.distanthorizons.common.render.blaze.util.BlazeDhVertexFormatUtil; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.RenderParams; @@ -84,8 +84,8 @@ public class BlazeDhTestTriangleRenderer implements IDhTestTriangleRenderer VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) - .add("vColor", DhBlazeVertexFormatUtil.RGBA_FLOAT_COLOR) + .add("vPosition", BlazeDhVertexFormatUtil.SCREEN_POS) + .add("vColor", BlazeDhVertexFormatUtil.RGBA_FLOAT_COLOR) .build(); //int breakpointOne = 0; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java similarity index 99% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java index 6631f63ad..810d77d4d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/DhBlazeVertexFormatUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java @@ -13,7 +13,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftCli /** * @see LodQuadBuilder */ -public class DhBlazeVertexFormatUtil +public class BlazeDhVertexFormatUtil { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index b14e861a0..bca3e31f5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -63,7 +63,7 @@ public class BlazePostProcessUtil public static VertexFormat createVertexFormat() { VertexFormat vertexFormat = VertexFormat.builder() - .add("vPosition", DhBlazeVertexFormatUtil.SCREEN_POS) + .add("vPosition", BlazeDhVertexFormatUtil.SCREEN_POS) .build(); return vertexFormat; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java similarity index 85% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java index eeb70b9d4..e9262a797 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/helpers/UniformHandler.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java @@ -1,12 +1,11 @@ -package com.seibel.distanthorizons.common.render.blaze.helpers; +package com.seibel.distanthorizons.common.render.blaze.util; import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; -@Deprecated // TODO use Uniform Wrapper instead -public class UniformHandler +public class BlazeUniformUtil { private static final GpuDevice GPU_DEVICE = RenderSystem.getDevice(); private static final CommandEncoder COMMAND_ENCODER = GPU_DEVICE.createCommandEncoder(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java index 826f928c8..0ac76e60e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java @@ -8,7 +8,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodCont import java.nio.ByteBuffer; -public class BlazeLodUniformBufferWrapper extends UniformBufferWrapper implements ILodContainerUniformBufferWrapper +public class BlazeLodUniformBufferWrapper extends BlazeUniformBufferWrapper implements ILodContainerUniformBufferWrapper { private boolean uploaded = false; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java index d0c448584..55b25e612 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/UniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java @@ -12,7 +12,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IUniform import java.nio.ByteBuffer; import java.nio.ByteOrder; -public class UniformBufferWrapper implements IUniformBufferWrapper +public class BlazeUniformBufferWrapper implements IUniformBufferWrapper { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -35,7 +35,7 @@ public class UniformBufferWrapper implements IUniformBufferWrapper //=============// //region - public UniformBufferWrapper(String name) { this.name = name; } + public BlazeUniformBufferWrapper(String name) { this.name = name; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java deleted file mode 100644 index f86222d66..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhRenderApiDefinition.java +++ /dev/null @@ -1,66 +0,0 @@ -package com.seibel.distanthorizons.common.render.nativeGl; - -import com.seibel.distanthorizons.common.render.nativeGl.generic.OpenGlGenericObjectRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.generic.OpenGlGenericObjectVertexContainer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.OpenGlDummyUniformData; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.DhFarFadeRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade.VanillaFadeRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog.DhFogRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao.DhSSAORenderer; -import com.seibel.distanthorizons.common.render.nativeGl.test.GlTestTriangleRenderer; -import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; - -public class OpenGlDhRenderApiDefinition extends AbstractDhRenderApiDefinition -{ - //=========// - // getters // - //=========// - //region - - public String getApiName() { return "OpenGL"; } - - //endregion - - - - //============// - // singletons // - //============// - //region - - @Override public IDhMetaRenderer getMetaRenderer() { return OpenGlDhMetaRenderer.INSTANCE; } - @Override public IDhTerrainRenderer getTerrainRenderer() { return DhTerrainShaderProgram.INSTANCE; } - @Override public IDhSsaoRenderer getSsaoRenderer() { return DhSSAORenderer.INSTANCE; } - @Override public IDhFogRenderer getFogRenderer() { return DhFogRenderer.INSTANCE; } - @Override public IDhFarFadeRenderer getFarFadeRenderer() { return DhFarFadeRenderer.INSTANCE; } - @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return OpenGlDebugWireframeRenderer.INSTANCE; } - - @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return VanillaFadeRenderer.INSTANCE; } - @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return GlTestTriangleRenderer.INSTANCE; } - - //endregion - - - - //===========// - // factories // - //===========// - //region - - @Override public IDhGenericRenderer createGenericRenderer() { return OpenGlGenericObjectRenderer.INSTANCE; } - - @Override public IVertexBufferWrapper createVboWrapper(String name) { return new GLVertexBuffer(); } - @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new OpenGlDummyUniformData(); } - @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new OpenGlGenericObjectVertexContainer(); } - - //endregion - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java deleted file mode 100644 index a9a4851fc..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhInternalTextureFormat.java +++ /dev/null @@ -1,130 +0,0 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; - -import org.lwjgl.opengl.GL11C; -import org.lwjgl.opengl.GL30C; -import org.lwjgl.opengl.GL31C; - -import java.util.Locale; -import java.util.Optional; - -public enum EDhInternalTextureFormat -{ - RGBA(GL11C.GL_RGBA, EGlVersion.GL_11, EDhPixelFormat.RGBA), - - // 8-bit normalized - R8(GL30C.GL_R8, EGlVersion.GL_30, EDhPixelFormat.RED), - RG8(GL30C.GL_RG8, EGlVersion.GL_30, EDhPixelFormat.RG), - RGB8(GL11C.GL_RGB8, EGlVersion.GL_11, EDhPixelFormat.RGB), - RGBA8(GL11C.GL_RGBA8, EGlVersion.GL_11, EDhPixelFormat.RGBA), - - // 8-bit signed normalized - R8_SNORM(GL31C.GL_R8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RED), - RG8_SNORM(GL31C.GL_RG8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RG), - RGB8_SNORM(GL31C.GL_RGB8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGB), - RGBA8_SNORM(GL31C.GL_RGBA8_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGBA), - - // 16-bit normalized - R16(GL30C.GL_R16, EGlVersion.GL_30, EDhPixelFormat.RED), - RG16(GL30C.GL_RG16, EGlVersion.GL_30, EDhPixelFormat.RG), - RGB16(GL11C.GL_RGB16, EGlVersion.GL_11, EDhPixelFormat.RGB), - RGBA16(GL11C.GL_RGBA16, EGlVersion.GL_11, EDhPixelFormat.RGBA), - - // 16-bit signed normalized - R16_SNORM(GL31C.GL_R16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RED), - RG16_SNORM(GL31C.GL_RG16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RG), - RGB16_SNORM(GL31C.GL_RGB16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGB), - RGBA16_SNORM(GL31C.GL_RGBA16_SNORM, EGlVersion.GL_31, EDhPixelFormat.RGBA), - - // 16-bit float - R16F(GL30C.GL_R16F, EGlVersion.GL_30, EDhPixelFormat.RED), - RG16F(GL30C.GL_RG16F, EGlVersion.GL_30, EDhPixelFormat.RG), - RGB16F(GL30C.GL_RGB16F, EGlVersion.GL_30, EDhPixelFormat.RGB), - RGBA16F(GL30C.GL_RGBA16F, EGlVersion.GL_30, EDhPixelFormat.RGBA), - - // 32-bit float - R32F(GL30C.GL_R32F, EGlVersion.GL_30, EDhPixelFormat.RED), - RG32F(GL30C.GL_RG32F, EGlVersion.GL_30, EDhPixelFormat.RG), - RGB32F(GL30C.GL_RGB32F, EGlVersion.GL_30, EDhPixelFormat.RGB), - RGBA32F(GL30C.GL_RGBA32F, EGlVersion.GL_30, EDhPixelFormat.RGBA), - - // 8-bit integer - R8I(GL30C.GL_R8I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG8I(GL30C.GL_RG8I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB8I(GL30C.GL_RGB8I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA8I(GL30C.GL_RGBA8I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // 8-bit unsigned integer - R8UI(GL30C.GL_R8UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG8UI(GL30C.GL_RG8UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB8UI(GL30C.GL_RGB8UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA8UI(GL30C.GL_RGBA8UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // 16-bit integer - R16I(GL30C.GL_R16I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG16I(GL30C.GL_RG16I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB16I(GL30C.GL_RGB16I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA16I(GL30C.GL_RGBA16I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // 16-bit unsigned integer - R16UI(GL30C.GL_R16UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG16UI(GL30C.GL_RG16UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB16UI(GL30C.GL_RGB16UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA16UI(GL30C.GL_RGBA16UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // 32-bit integer - R32I(GL30C.GL_R32I, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG32I(GL30C.GL_RG32I, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB32I(GL30C.GL_RGB32I, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA32I(GL30C.GL_RGBA32I, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // 32-bit unsigned integer - R32UI(GL30C.GL_R32UI, EGlVersion.GL_30, EDhPixelFormat.RED_INTEGER), - RG32UI(GL30C.GL_RG32UI, EGlVersion.GL_30, EDhPixelFormat.RG_INTEGER), - RGB32UI(GL30C.GL_RGB32UI, EGlVersion.GL_30, EDhPixelFormat.RGB_INTEGER), - RGBA32UI(GL30C.GL_RGBA32UI, EGlVersion.GL_30, EDhPixelFormat.RGBA_INTEGER), - - // Mixed - R3_G3_B2(GL11C.GL_R3_G3_B2, EGlVersion.GL_11, EDhPixelFormat.RGB), - RGB5_A1(GL11C.GL_RGB5_A1, EGlVersion.GL_11, EDhPixelFormat.RGBA), - RGB10_A2(GL11C.GL_RGB10_A2, EGlVersion.GL_11, EDhPixelFormat.RGBA), - R11F_G11F_B10F(GL30C.GL_R11F_G11F_B10F, EGlVersion.GL_30, EDhPixelFormat.RGB), - RGB9_E5(GL30C.GL_RGB9_E5, EGlVersion.GL_30, EDhPixelFormat.RGB); - - - - private final int glFormat; - private final EGlVersion minimumGlVersion; - private final EDhPixelFormat expectedPixelFormat; - - - - EDhInternalTextureFormat(int glFormat, EGlVersion minimumGlVersion, EDhPixelFormat expectedPixelFormat) - { - this.glFormat = glFormat; - this.minimumGlVersion = minimumGlVersion; - this.expectedPixelFormat = expectedPixelFormat; - } - - - - public static Optional fromString(String name) - { - try - { - return Optional.of(EDhInternalTextureFormat.valueOf(name.toUpperCase(Locale.US))); - } - catch (IllegalArgumentException e) - { - return Optional.empty(); - } - } - - public int getGlFormat() { return this.glFormat; } - - public EDhPixelFormat getPixelFormat() { return this.expectedPixelFormat; } - - public EGlVersion getMinimumGlVersion() { return this.minimumGlVersion; } - - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java deleted file mode 100644 index 6a256d2d3..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EGlVersion.java +++ /dev/null @@ -1,9 +0,0 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; - -public enum EGlVersion -{ - GL_11, - GL_12, - GL_30, - GL_31 -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java deleted file mode 100644 index e05b2a621..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexPointer.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; - -import com.seibel.distanthorizons.coreapi.util.MathUtil; -import org.lwjgl.opengl.GL32; - -public final class VertexPointer -{ - public final int elementCount; - public final int glType; - public final boolean normalized; - public final int byteSize; - public final boolean useInteger; - - - - // basic constructors // - - public VertexPointer(int elementCount, int glType, boolean normalized, int byteSize, boolean useInteger) - { - this.elementCount = elementCount; - this.glType = glType; - this.normalized = normalized; - this.byteSize = byteSize; - this.useInteger = useInteger; - } - public VertexPointer(int elementCount, int glType, boolean normalized, int byteSize) - { - this(elementCount, glType, normalized, byteSize, false); - } - private static int _align(int bytes) { return MathUtil.ceilDiv(bytes, 4) * 4; } - - - - // named constructors // - - public static VertexPointer addFloatPointer(boolean normalized) { return new VertexPointer(1, GL32.GL_FLOAT, normalized, Float.BYTES); } - public static VertexPointer addVec2Pointer(boolean normalized) { return new VertexPointer(2, GL32.GL_FLOAT, normalized, Float.BYTES * 2); } - public static VertexPointer addVec3Pointer(boolean normalized) { return new VertexPointer(3, GL32.GL_FLOAT, normalized, Float.BYTES * 3); } - public static VertexPointer addVec4Pointer(boolean normalized) { return new VertexPointer(4, GL32.GL_FLOAT, normalized, Float.BYTES * 4); } - /** Always aligned to 4 bytes */ - public static VertexPointer addUnsignedBytePointer(boolean normalized, boolean useInteger) { return new VertexPointer(1, GL32.GL_UNSIGNED_BYTE, normalized, 4, useInteger); } - /** aligned to 4 bytes */ - public static VertexPointer addUnsignedBytesPointer(int elementCount, boolean normalized, boolean useInteger) - { return new VertexPointer(elementCount, GL32.GL_UNSIGNED_BYTE, normalized, _align(elementCount), useInteger); } - public static VertexPointer addUnsignedShortsPointer(int elementCount, boolean normalized, boolean useInteger) - { return new VertexPointer(elementCount, GL32.GL_UNSIGNED_SHORT, normalized, _align(elementCount * 2), useInteger); } - public static VertexPointer addShortsPointer(int elementCount, boolean normalized, boolean useInteger) { return new VertexPointer(elementCount, GL32.GL_SHORT, normalized, _align(elementCount * 2), useInteger); } - public static VertexPointer addIntPointer(boolean normalized, boolean useInteger) { return new VertexPointer(1, GL32.GL_INT, normalized, 4, useInteger); } - public static VertexPointer addIVec2Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(2, GL32.GL_INT, normalized, 8, useInteger); } - public static VertexPointer addIVec3Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(3, GL32.GL_INT, normalized, 12, useInteger); } - public static VertexPointer addIVec4Pointer(boolean normalized, boolean useInteger) { return new VertexPointer(4, GL32.GL_INT, normalized, 16, useInteger); } - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java b/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java deleted file mode 100644 index 714eab500..000000000 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogSettings.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * This file is part of the Distant Horizons mod - * licensed under the GNU LGPL v3 License. - * - * Copyright (C) 2020 James Seibel - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation, version 3. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program. If not, see . - */ - -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; - -import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogFalloff; - -import java.util.Objects; - -/** - * Contains all configurable options related to fog. - * - * @version 2022-4-13 - */ -public class FogSettings -{ - /** a FogSetting object with 0 for every value */ - public static final FogSettings EMPTY = new FogSettings(0, 0, 0, 0, 0, EDhApiFogFalloff.LINEAR); - - - public final double start; - public final double end; - public final double min; - public final double max; - public final double density; - public final EDhApiFogFalloff fogType; - - public FogSettings(double start, double end, double min, double max, double density, EDhApiFogFalloff fogType) - { - this.start = start; - this.end = end; - this.min = min; - this.max = max; - this.density = density; - this.fogType = fogType; - } - - @Override - public boolean equals(Object o) - { - if (this == o) - return true; - if (o == null || getClass() != o.getClass()) - return false; - FogSettings that = (FogSettings) o; - return Double.compare(that.start, start) == 0 && Double.compare(that.end, end) == 0 && Double.compare(that.min, min) == 0 && Double.compare(that.max, max) == 0 && Double.compare(that.density, density) == 0 && fogType == that.fogType; - } - - @Override - public int hashCode() - { - return Objects.hash(start, end, min, max, density, fogType); - } - - -} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java similarity index 83% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java index f0fc8af05..13d225995 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java @@ -17,13 +17,13 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl; +package com.seibel.distanthorizons.common.render.openGl; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLElementBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -39,9 +39,9 @@ import java.nio.ByteOrder; * Handles rendering the wireframe particles * that are used for seeing what the system's doing. */ -public class OpenGlDebugWireframeRenderer extends AbstractDebugWireframeRenderer +public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer { - public static OpenGlDebugWireframeRenderer INSTANCE = new OpenGlDebugWireframeRenderer(); + public static GlDhDebugWireframeRenderer INSTANCE = new GlDhDebugWireframeRenderer(); public static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -50,9 +50,9 @@ public class OpenGlDebugWireframeRenderer extends AbstractDebugWireframeRenderer // rendering setup - private ShaderProgram basicShader; + private GlShaderProgram basicShader; private GLElementBuffer outlineIndexBuffer; - private AbstractVertexAttribute va; + private GlAbstractVertexAttribute va; private boolean init = false; @@ -98,7 +98,7 @@ public class OpenGlDebugWireframeRenderer extends AbstractDebugWireframeRenderer //=============// //region - private OpenGlDebugWireframeRenderer() { } + private GlDhDebugWireframeRenderer() { } public void init() { @@ -108,12 +108,12 @@ public class OpenGlDebugWireframeRenderer extends AbstractDebugWireframeRenderer } this.init = true; - this.va = AbstractVertexAttribute.create(); + this.va = GlAbstractVertexAttribute.create(); this.va.bind(); // Pos - this.va.setVertexAttribute(0, 0, VertexPointer.addVec3Pointer(false)); + this.va.setVertexAttribute(0, 0, GlVertexPointer.addVec3Pointer(false)); this.va.completeAndCheck(Float.BYTES * 3); - this.basicShader = new ShaderProgram( + this.basicShader = new GlShaderProgram( "shaders/debug/vert.vert", "shaders/debug/frag.frag", "vPosition" diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhMetaRenderer.java similarity index 88% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhMetaRenderer.java index 8e7c26b33..eba0bae3d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/OpenGlDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhMetaRenderer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl; +package com.seibel.distanthorizons.common.render.openGl; import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; @@ -6,10 +6,11 @@ import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShader import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiTextureCreatedParam; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.texture.*; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.GlDhFramebuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GlQuadElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.texture.*; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.apply.GlDhApplyShader; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -28,7 +29,7 @@ import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; import org.jetbrains.annotations.Nullable; import org.lwjgl.opengl.GL32; -public class OpenGlDhMetaRenderer implements IDhMetaRenderer +public class GlDhMetaRenderer implements IDhMetaRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder() .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) @@ -39,7 +40,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer .maxCountPerSecond(4) .build(); - public static final OpenGlDhMetaRenderer INSTANCE = new OpenGlDhMetaRenderer(); + public static final GlDhMetaRenderer INSTANCE = new GlDhMetaRenderer(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); @@ -57,10 +58,10 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer private IDhApiFramebuffer framebuffer; /** will be null if MC's framebuffer is being used since MC already has a color texture */ @Nullable - private DhColorTexture nullableColorTexture; - private DHDepthTexture depthTexture; + private GlDhColorTexture nullableColorTexture; + private GlDhDepthTexture depthTexture; /** - * If true the {@link OpenGlDhMetaRenderer#framebuffer} is the same as MC's. + * If true the {@link GlDhMetaRenderer#framebuffer} is the same as MC's. * This should only be true in the case of Optifine so LODs won't be overwritten when shaders are enabled. */ private boolean usingMcFramebuffer = false; @@ -95,7 +96,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer this.renderObjectsCreated = true; } - this.shaderProgramForThisFrame = DhTerrainShaderProgram.INSTANCE; + this.shaderProgramForThisFrame = GlDhTerrainShaderProgram.INSTANCE; IDhApiShaderProgram lodShaderProgramOverride = OverrideInjector.INSTANCE.get(IDhApiShaderProgram.class); if (lodShaderProgramOverride != null && this.shaderProgramForThisFrame.overrideThisFrame()) { @@ -105,7 +106,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer this.setGLState(renderParams, firstPass); - DhTerrainShaderProgram.INSTANCE.quadIBO.bind(); + GlDhTerrainShaderProgram.INSTANCE.quadIBO.bind(); this.bindLightmap(renderParams.lightmap); } private void setGLState( @@ -213,7 +214,7 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer { // Due to using MC/Optifine's framebuffer we need to re-bind the depth texture, // otherwise we'll be writing to MC/Optifine's depth texture which causes rendering issues - framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EGlDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); // don't clear the color texture, that removes the sky @@ -241,8 +242,8 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer LOGGER.info("Setting up renderer"); - DhTerrainShaderProgram.INSTANCE.quadIBO = new QuadElementBuffer(); - DhTerrainShaderProgram.INSTANCE.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); + GlDhTerrainShaderProgram.INSTANCE.quadIBO = new GlQuadElementBuffer(); + GlDhTerrainShaderProgram.INSTANCE.quadIBO.reserve(LodQuadBuilder.getMaxBufferByteSize()); // create or get the frame buffer @@ -250,13 +251,13 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer { // use MC/Optifine's default Framebuffer so shaders won't remove the LODs int currentFramebufferId = MC_RENDER.getTargetFramebuffer(); - this.framebuffer = new DhFramebuffer(currentFramebufferId); + this.framebuffer = new GlDhFramebuffer(currentFramebufferId); this.usingMcFramebuffer = true; } else { // normal use case - this.framebuffer = new DhFramebuffer(); + this.framebuffer = new GlDhFramebuffer(); this.usingMcFramebuffer = false; } @@ -299,22 +300,22 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer IDhApiFramebuffer framebufferOverride = OverrideInjector.INSTANCE.get(IDhApiFramebuffer.class); - this.depthTexture = new DHDepthTexture(this.textureWidth, this.textureHeight, EDhDepthBufferFormat.DEPTH32F); - this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + this.depthTexture = new GlDhDepthTexture(this.textureWidth, this.textureHeight, EGlDhDepthBufferFormat.DEPTH32F); + this.framebuffer.addDepthAttachment(this.depthTexture.getTextureId(), EGlDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); if (framebufferOverride != null) { - framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); + framebufferOverride.addDepthAttachment(this.depthTexture.getTextureId(), EGlDhDepthBufferFormat.DEPTH32F.isCombinedStencil()); } // if we are using MC's frame buffer, a color texture is already present and shouldn't need to be bound if (!this.usingMcFramebuffer) { - this.nullableColorTexture = DhColorTexture.builder() + this.nullableColorTexture = GlDhColorTexture.builder() .setDimensions(this.textureWidth, this.textureHeight) - .setInternalFormat(EDhInternalTextureFormat.RGBA8) - .setPixelType(EDhPixelType.UNSIGNED_BYTE) - .setPixelFormat(EDhPixelFormat.RGBA) + .setInternalFormat(EGlDhInternalTextureFormat.RGBA8) + .setPixelType(EGlDhPixelType.UNSIGNED_BYTE) + .setPixelFormat(EGlDhPixelFormat.RGBA) .build(); this.framebuffer.addColorAttachment(0, this.nullableColorTexture.getTextureId()); @@ -361,12 +362,12 @@ public class OpenGlDhMetaRenderer implements IDhMetaRenderer this.unbindLightmap(); - DhTerrainShaderProgram.INSTANCE.quadIBO.unbind(); + GlDhTerrainShaderProgram.INSTANCE.quadIBO.unbind(); this.shaderProgramForThisFrame.unbind(); } @Override - public void applyToMcTexture(RenderParams renderParams) { DhApplyShader.INSTANCE.render(renderParams); } + public void applyToMcTexture(RenderParams renderParams) { GlDhApplyShader.INSTANCE.render(renderParams); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhRenderApiDefinition.java new file mode 100644 index 000000000..7c6f0afdc --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhRenderApiDefinition.java @@ -0,0 +1,66 @@ +package com.seibel.distanthorizons.common.render.openGl; + +import com.seibel.distanthorizons.common.render.openGl.generic.GlGenericObjectRenderer; +import com.seibel.distanthorizons.common.render.openGl.generic.GlGenericObjectVertexContainer; +import com.seibel.distanthorizons.common.render.openGl.glObject.GlDummyUniformData; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.fade.GlDhFarFadeRenderer; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.fade.GlVanillaFadeRenderer; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.fog.GlDhFogRenderer; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.ssao.GlDhSSAORenderer; +import com.seibel.distanthorizons.common.render.openGl.test.GlTestTriangleRenderer; +import com.seibel.distanthorizons.core.render.renderer.AbstractDebugWireframeRenderer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.AbstractDhRenderApiDefinition; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IDhGenericObjectVertexBufferContainer; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; +import com.seibel.distanthorizons.core.wrapperInterfaces.render.renderPass.*; + +public class GlDhRenderApiDefinition extends AbstractDhRenderApiDefinition +{ + //=========// + // getters // + //=========// + //region + + public String getApiName() { return "OpenGL"; } + + //endregion + + + + //============// + // singletons // + //============// + //region + + @Override public IDhMetaRenderer getMetaRenderer() { return GlDhMetaRenderer.INSTANCE; } + @Override public IDhTerrainRenderer getTerrainRenderer() { return GlDhTerrainShaderProgram.INSTANCE; } + @Override public IDhSsaoRenderer getSsaoRenderer() { return GlDhSSAORenderer.INSTANCE; } + @Override public IDhFogRenderer getFogRenderer() { return GlDhFogRenderer.INSTANCE; } + @Override public IDhFarFadeRenderer getFarFadeRenderer() { return GlDhFarFadeRenderer.INSTANCE; } + @Override public AbstractDebugWireframeRenderer getDebugWireframeRenderer() { return GlDhDebugWireframeRenderer.INSTANCE; } + + @Override public IDhVanillaFadeRenderer getVanillaFadeRenderer() { return GlVanillaFadeRenderer.INSTANCE; } + @Override public IDhTestTriangleRenderer getTestTriangleRenderer() { return GlTestTriangleRenderer.INSTANCE; } + + //endregion + + + + //===========// + // factories // + //===========// + //region + + @Override public IDhGenericRenderer createGenericRenderer() { return GlGenericObjectRenderer.INSTANCE; } + + @Override public IVertexBufferWrapper createVboWrapper(String name) { return new GLVertexBuffer(); } + @Override public ILodContainerUniformBufferWrapper createLodContainerUniformWrapper() { return new GlDummyUniformData(); } + @Override public IDhGenericObjectVertexBufferContainer createGenericVboContainer() { return new GlGenericObjectVertexContainer(); } + + //endregion + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java similarity index 84% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java index c9bd18b01..04e7a2f02 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/DhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java @@ -17,21 +17,21 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl; +package com.seibel.distanthorizons.common.render.openGl; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShaderProgram; import com.seibel.distanthorizons.api.methods.events.abstractEvents.*; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.QuadElementBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePostGL43; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexAttributePreGL43; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; -import com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat.LodVertexFormat; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GlQuadElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexAttributePostGL43; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexAttributePreGL43; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; +import com.seibel.distanthorizons.common.render.openGl.util.vertexFormat.GlLodVertexFormat; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.config.Config; @@ -57,21 +57,21 @@ import org.lwjgl.opengl.GL32; * Handles rendering the normal LOD terrain. * @see LodQuadBuilder */ -public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShaderProgram, IDhTerrainRenderer +public class GlDhTerrainShaderProgram extends GlShaderProgram implements IDhApiShaderProgram, IDhTerrainRenderer { public static final DhLogger LOGGER = new DhLoggerBuilder() .fileLevelConfig(Config.Common.Logging.logRendererEventToFile) .build(); - public static final DhTerrainShaderProgram INSTANCE = new DhTerrainShaderProgram(); + public static final GlDhTerrainShaderProgram INSTANCE = new GlDhTerrainShaderProgram(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; private static final IIrisAccessor IRIS_ACCESSOR = ModAccessorInjector.INSTANCE.get(IIrisAccessor.class); - public QuadElementBuffer quadIBO = null; - public final AbstractVertexAttribute vao; + public GlQuadElementBuffer quadIBO = null; + public final GlAbstractVertexAttribute vao; // uniforms // //region @@ -106,7 +106,7 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade //=============// //region - private DhTerrainShaderProgram() + private GlDhTerrainShaderProgram() { super( "shaders/standard.vert", @@ -138,30 +138,30 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade if (GLProxy.getInstance().vertexAttributeBufferBindingSupported) { - this.vao = new VertexAttributePostGL43(); // also binds AbstractVertexAttribute + this.vao = new GlVertexAttributePostGL43(); // also binds AbstractVertexAttribute } else { - this.vao = new VertexAttributePreGL43(); // also binds AbstractVertexAttribute + this.vao = new GlVertexAttributePreGL43(); // also binds AbstractVertexAttribute } this.vao.bind(); // short: x, y, z, meta // meta: byte skylight, byte blocklight, byte microOffset - this.vao.setVertexAttribute(0, 0, VertexPointer.addUnsignedShortsPointer(4, false, true)); + this.vao.setVertexAttribute(0, 0, GlVertexPointer.addUnsignedShortsPointer(4, false, true)); // byte: r, g, b, a - this.vao.setVertexAttribute(0, 1, VertexPointer.addUnsignedBytesPointer(4, true, false)); + this.vao.setVertexAttribute(0, 1, GlVertexPointer.addUnsignedBytesPointer(4, true, false)); // byte: iris material ID, normal index, 2 spacers - this.vao.setVertexAttribute(0, 2, VertexPointer.addUnsignedBytesPointer(4, true, true)); + this.vao.setVertexAttribute(0, 2, GlVertexPointer.addUnsignedBytesPointer(4, true, true)); try { - int vertexByteCount = LodVertexFormat.DH_VERTEX_FORMAT.getByteSize(); + int vertexByteCount = GlLodVertexFormat.DH_VERTEX_FORMAT.getByteSize(); this.vao.completeAndCheck(vertexByteCount); } catch (RuntimeException e) { - System.out.println(LodVertexFormat.DH_VERTEX_FORMAT); + System.out.println(GlLodVertexFormat.DH_VERTEX_FORMAT); throw e; } @@ -331,8 +331,8 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade (float) (bufferContainer.minCornerBlockPos.getY() - camPos.y), (float) (bufferContainer.minCornerBlockPos.getZ() - camPos.z)); - OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bind(); - OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.setModelOffsetPos(modelPos); + GlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bind(); + GlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.setModelOffsetPos(modelPos); ApiEventInjector.INSTANCE.fireAllEvents(DhApiBeforeBufferRenderEvent.class, new DhApiBeforeBufferRenderEvent.EventParam(renderEventParam, modelPos)); } @@ -355,7 +355,7 @@ public class DhTerrainShaderProgram extends ShaderProgram implements IDhApiShade int indexCount = (int)(vbo.getVertexCount() * 1.5); vbo.bind(); - OpenGlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bindVertexBuffer(vbo.getId()); + GlDhMetaRenderer.INSTANCE.shaderProgramForThisFrame.bindVertexBuffer(vbo.getId()); GL32.glDrawElements( GL32.GL_TRIANGLES, indexCount, diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectRenderer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectRenderer.java index 30ca56132..7e38e00e7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectRenderer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.generic; +package com.seibel.distanthorizons.common.render.openGl.generic; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; import com.seibel.distanthorizons.api.enums.rendering.EDhApiBlockMaterial; @@ -29,9 +29,9 @@ import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhAp import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLElementBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; @@ -66,7 +66,7 @@ import java.util.concurrent.ConcurrentHashMap; * @see IDhApiCustomRenderRegister * @see DhApiRenderableBox */ -public class OpenGlGenericObjectRenderer implements IDhGenericRenderer +public class GlGenericObjectRenderer implements IDhGenericRenderer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -76,7 +76,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer private static final DhApiRenderableBoxGroupShading DEFAULT_SHADING = DhApiRenderableBoxGroupShading.getUnshaded(); - public static final OpenGlGenericObjectRenderer INSTANCE = new OpenGlGenericObjectRenderer(); + public static final GlGenericObjectRenderer INSTANCE = new GlGenericObjectRenderer(); /** * Can be used to troubleshoot the renderer. @@ -176,7 +176,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer //=============// //region - private OpenGlGenericObjectRenderer() { } + private GlGenericObjectRenderer() { } public void init() { @@ -207,8 +207,8 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer // startup the renderer // //======================// - this.instancedShaderProgram = new GenericObjectShaderProgram(true); - this.directShaderProgram = new GenericObjectShaderProgram(false); + this.instancedShaderProgram = new GlGenericObjectShaderProgram(true); + this.directShaderProgram = new GlGenericObjectShaderProgram(false); this.createBuffers(); @@ -478,7 +478,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer boxGroup.tryUpdateInstancedDataAsync(); // skip groups that haven't been uploaded yet - if (boxGroup.vertexBufferContainer.getState() != OpenGlGenericObjectVertexContainer.EState.RENDER) + if (boxGroup.vertexBufferContainer.getState() != GlGenericObjectVertexContainer.EState.RENDER) { continue; } @@ -560,7 +560,7 @@ public class OpenGlGenericObjectRenderer implements IDhGenericRenderer // Bind instance data // profiler.popPush("binding"); - OpenGlGenericObjectVertexContainer container = (OpenGlGenericObjectVertexContainer)(boxGroup.vertexBufferContainer); + GlGenericObjectVertexContainer container = (GlGenericObjectVertexContainer)(boxGroup.vertexBufferContainer); GL32.glBindBuffer(GL32.GL_ARRAY_BUFFER, container.color); GL32.glEnableVertexAttribArray(1); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java similarity index 91% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java index 8635e7554..6340213c2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/GenericObjectShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl.generic; +package com.seibel.distanthorizons.common.render.openGl.generic; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiGenericObjectShaderProgram; import com.seibel.distanthorizons.api.interfaces.render.IDhApiRenderableBoxGroup; @@ -7,23 +7,22 @@ import com.seibel.distanthorizons.api.objects.math.DhApiVec3d; import com.seibel.distanthorizons.api.objects.math.DhApiVec3i; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBoxGroupShading; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.util.math.Vec3f; -import com.seibel.distanthorizons.core.wrapperInterfaces.misc.ILightMapWrapper; -public class GenericObjectShaderProgram extends ShaderProgram implements IDhApiGenericObjectShaderProgram +public class GlGenericObjectShaderProgram extends GlShaderProgram implements IDhApiGenericObjectShaderProgram { public static final String VERTEX_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/vert.vert"; public static final String VERTEX_SHADER_DIRECT_PATH = "shaders/genericObject/direct/vert.vert"; public static final String FRAGMENT_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/frag.frag"; public static final String FRAGMENT_SHADER_DIRECT_PATH = "shaders/genericObject/direct/frag.frag"; - public final AbstractVertexAttribute va; + public final GlAbstractVertexAttribute va; // shader uniforms @@ -53,7 +52,7 @@ public class GenericObjectShaderProgram extends ShaderProgram implements IDhApiG // constructor // //=============// - public GenericObjectShaderProgram(boolean useInstancedRendering) + public GlGenericObjectShaderProgram(boolean useInstancedRendering) { super( useInstancedRendering ? VERTEX_SHADER_INSTANCED_PATH : VERTEX_SHADER_DIRECT_PATH, @@ -61,10 +60,10 @@ public class GenericObjectShaderProgram extends ShaderProgram implements IDhApiG "vPosition" ); - this.va = AbstractVertexAttribute.create(); + this.va = GlAbstractVertexAttribute.create(); this.va.bind(); // Pos - this.va.setVertexAttribute(0, 0, VertexPointer.addVec3Pointer(false)); + this.va.setVertexAttribute(0, 0, GlVertexPointer.addVec3Pointer(false)); this.va.completeAndCheck(Float.BYTES * 3); this.directShaderTransformUniform = this.tryGetUniformLocation("uTransform"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectVertexContainer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectVertexContainer.java index c2c6fc29b..48eb20f31 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/generic/OpenGlGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectVertexContainer.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl.generic; +package com.seibel.distanthorizons.common.render.openGl.generic; import com.seibel.distanthorizons.api.objects.render.DhApiRenderableBox; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; @@ -17,7 +17,7 @@ import java.util.List; * * @see RenderableBoxGroup */ -public class OpenGlGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer +public class GlGenericObjectVertexContainer implements IDhGenericObjectVertexBufferContainer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -106,7 +106,7 @@ public class OpenGlGenericObjectVertexContainer implements IDhGenericObjectVerte this.materialData[i] = box.material; } - this.state = OpenGlGenericObjectVertexContainer.EState.READY_TO_UPLOAD; + this.state = GlGenericObjectVertexContainer.EState.READY_TO_UPLOAD; } public void uploadDataToGpu() diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLProxy.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLProxy.java index 1e0280cc8..5a3b2af90 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLProxy.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLProxy.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject; +package com.seibel.distanthorizons.common.render.openGl.glObject; import com.seibel.distanthorizons.api.enums.config.EDhApiGLErrorHandlingMode; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; @@ -26,10 +26,8 @@ import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.jar.EPlatform; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.core.util.TimerUtil; import com.seibel.distanthorizons.core.util.objects.GLMessages.*; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; -import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import com.seibel.distanthorizons.coreapi.ModInfo; import org.lwjgl.glfw.GLFW; import org.lwjgl.opengl.GL; @@ -40,9 +38,7 @@ import org.lwjgl.opengl.GLUtil; import java.io.PrintStream; import java.util.Collections; import java.util.Set; -import java.util.Timer; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentLinkedQueue; /** * A singleton that holds references to different openGL contexts diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLState.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLState.java index d3511539b..6107a7a24 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLState.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GLState.java @@ -17,10 +17,10 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject; +package com.seibel.distanthorizons.common.render.openGl.glObject; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.GLEnums; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import org.lwjgl.opengl.GL32; public class GLState implements AutoCloseable diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDhFramebuffer.java similarity index 83% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDhFramebuffer.java index 3035e850d..24fd69a46 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhFramebuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDhFramebuffer.java @@ -1,12 +1,10 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import it.unimi.dsi.fastutil.ints.Int2IntArrayMap; -import it.unimi.dsi.fastutil.ints.Int2IntMap; import org.lwjgl.opengl.GL32; -public class DhFramebuffer implements IDhApiFramebuffer +public class GlDhFramebuffer implements IDhApiFramebuffer { private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -19,10 +17,10 @@ public class DhFramebuffer implements IDhApiFramebuffer //=============// //region - public DhFramebuffer() { this.id = GL32.glGenFramebuffers(); } + public GlDhFramebuffer() { this.id = GL32.glGenFramebuffers(); } /** For internal use by Iris, do not remove. */ - public DhFramebuffer(int id) { this.id = id; } + public GlDhFramebuffer(int id) { this.id = id; } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDummyUniformData.java similarity index 77% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDummyUniformData.java index 03df57f71..43f0f35c8 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/OpenGlDummyUniformData.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/GlDummyUniformData.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject; +package com.seibel.distanthorizons.common.render.openGl.glObject; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodContainerUniformBufferWrapper; @@ -7,7 +7,7 @@ import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.ILodCont * With OpenGL all uniform data is uploaded during the rendering phase * so nothing is needed here. */ -public class OpenGlDummyUniformData implements ILodContainerUniformBufferWrapper +public class GlDummyUniformData implements ILodContainerUniformBufferWrapper { @Override public void createUniformData(LodBufferContainer bufferContainer) { } @Override public void tryUpload() { } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLBuffer.java similarity index 97% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLBuffer.java index c9332b60e..8b62b5d37 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLBuffer.java @@ -17,13 +17,12 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; +package com.seibel.distanthorizons.common.render.openGl.glObject.buffer; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLElementBuffer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLElementBuffer.java index d69818bf6..2f6c042bf 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLElementBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLElementBuffer.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; +package com.seibel.distanthorizons.common.render.openGl.glObject.buffer; import org.lwjgl.opengl.GL32; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLVertexBuffer.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLVertexBuffer.java index 797331b37..5567c7cf2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/GLVertexBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GLVertexBuffer.java @@ -17,11 +17,11 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; +package com.seibel.distanthorizons.common.render.openGl.glObject.buffer; import java.nio.ByteBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodQuadBuilder; import com.seibel.distanthorizons.core.wrapperInterfaces.render.objects.IVertexBufferWrapper; import org.lwjgl.opengl.GL32; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GlQuadElementBuffer.java similarity index 94% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GlQuadElementBuffer.java index 953d4dae4..c0bcca307 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/buffer/QuadElementBuffer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/buffer/GlQuadElementBuffer.java @@ -17,10 +17,10 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer; +package com.seibel.distanthorizons.common.render.openGl.glObject.buffer; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLEnums; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.GLEnums; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import org.lwjgl.opengl.GL32; @@ -29,7 +29,7 @@ import org.lwjgl.system.MemoryUtil; import java.nio.ByteBuffer; /** AKA Index Buffer TODO RENAME */ -public class QuadElementBuffer extends GLElementBuffer +public class GlQuadElementBuffer extends GLElementBuffer { private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -40,7 +40,7 @@ public class QuadElementBuffer extends GLElementBuffer //=============// //region - public QuadElementBuffer() { super(false); } + public GlQuadElementBuffer() { super(false); } public void reserve(int quadCount) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/EGlVersion.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/EGlVersion.java new file mode 100644 index 000000000..2387ee8e8 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/EGlVersion.java @@ -0,0 +1,9 @@ +package com.seibel.distanthorizons.common.render.openGl.glObject.enums; + +public enum EGlVersion +{ + GL_11, + GL_12, + GL_30, + GL_31 +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/GLEnums.java similarity index 98% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/GLEnums.java index f9fa9b921..36cdd09d2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/GLEnums.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/enums/GLEnums.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject; +package com.seibel.distanthorizons.common.render.openGl.glObject.enums; import static org.lwjgl.opengl.GL46.*; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShader.java similarity index 95% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShader.java index cd2174386..52c568245 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/Shader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShader.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.shader; +package com.seibel.distanthorizons.common.render.openGl.glObject.shader; import java.io.BufferedReader; import java.io.FileInputStream; @@ -41,7 +41,7 @@ import org.lwjgl.system.NativeType; * This object holds a OpenGL reference to a shader * and allows for reading in and compiling a shader file. */ -public class Shader +public class GlShader { private static final DhLogger LOGGER = new DhLoggerBuilder() .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) @@ -66,7 +66,7 @@ public class Shader * @param sourceString File path of the shader * @throws RuntimeException if the shader fails to compile */ - public Shader(int type, String sourceString) + public GlShader(int type, String sourceString) { LOGGER.info("Loading shader with type: ["+type+"]"); LOGGER.debug("Source: \n["+sourceString+"]"); @@ -154,7 +154,7 @@ public class Shader } else { - in = Shader.class.getClassLoader().getResourceAsStream(path); // Note: path seperator should be '/' + in = GlShader.class.getClassLoader().getResourceAsStream(path); // Note: path seperator should be '/' if (in == null) { throw new FileNotFoundException("Shader file not found in resource: " + path); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShaderProgram.java similarity index 86% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShaderProgram.java index 97ef510f4..011de6d41 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/shader/ShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/shader/GlShaderProgram.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.shader; +package com.seibel.distanthorizons.common.render.openGl.glObject.shader; import java.awt.Color; import java.nio.FloatBuffer; @@ -36,7 +36,7 @@ import com.seibel.distanthorizons.core.util.math.Vec3f; * The reason for many of these simple wrapper methods is as reminders of what * can (and needs to be) done with a shader program. */ -public class ShaderProgram +public class GlShaderProgram { /** Stores the handle of the program. */ public final int id; @@ -48,25 +48,25 @@ public class ShaderProgram //=============// //region - public ShaderProgram(String vertResourcePath, String fragResourcePath, String attribute) { this(vertResourcePath, fragResourcePath, new String[]{ attribute }); } + public GlShaderProgram(String vertResourcePath, String fragResourcePath, String attribute) { this(vertResourcePath, fragResourcePath, new String[]{ attribute }); } /** * @param vertResourcePath the relative path the vertex shader should be found * @param fragResourcePath the relative path the fragment shader should be found */ - public ShaderProgram(String vertResourcePath, String fragResourcePath, String[] attributes) + public GlShaderProgram(String vertResourcePath, String fragResourcePath, String[] attributes) { this.id = GL32.glCreateProgram(); { - String shaderString = Shader.loadFile(vertResourcePath, false); - Shader vertShader = new Shader(GL32.GL_VERTEX_SHADER, shaderString); + String shaderString = GlShader.loadFile(vertResourcePath, false); + GlShader vertShader = new GlShader(GL32.GL_VERTEX_SHADER, shaderString); GL32.glAttachShader(this.id, vertShader.id); vertShader.free(); } { - String shaderString = Shader.loadFile(fragResourcePath, false); - Shader fragShader = new Shader(GL32.GL_FRAGMENT_SHADER, shaderString); + String shaderString = GlShader.loadFile(fragResourcePath, false); + GlShader fragShader = new GlShader(GL32.GL_FRAGMENT_SHADER, shaderString); GL32.glAttachShader(this.id, fragShader.id); fragShader.free(); } @@ -167,27 +167,27 @@ public class ShaderProgram /** Requires a bound ShaderProgram. */ public void setUniform(int location, boolean value) { GL32.glUniform1i(location, value ? 1 : 0); } - /** @see ShaderProgram#setUniform(int, boolean) */ + /** @see GlShaderProgram#setUniform(int, boolean) */ public void trySetUniform(int location, boolean value) { if (location != -1) { this.setUniform(location, value); } } /** Requires a bound ShaderProgram. */ public void setUniform(int location, int value) { GL32.glUniform1i(location, value); } - /** @see ShaderProgram#setUniform(int, int) */ + /** @see GlShaderProgram#setUniform(int, int) */ public void trySetUniform(int location, int value) { if (location != -1) { this.setUniform(location, value); } } /** Requires a bound ShaderProgram. */ public void setUniform(int location, float value) { GL32.glUniform1f(location, value); } - /** @see ShaderProgram#setUniform(int, float) */ + /** @see GlShaderProgram#setUniform(int, float) */ public void trySetUniform(int location, float value) { if (location != -1) { this.setUniform(location, value); } } /** Requires a bound ShaderProgram. */ public void setUniform(int location, Vec3f value) { GL32.glUniform3f(location, value.x, value.y, value.z); } - /** @see ShaderProgram#setUniform(int, Vec3f) */ + /** @see GlShaderProgram#setUniform(int, Vec3f) */ public void trySetUniform(int location, Vec3f value) { if (location != -1) { this.setUniform(location, value); } } /** Requires a bound ShaderProgram. */ public void setUniform(int location, DhApiVec3i value) { GL32.glUniform3i(location, value.x, value.y, value.z); } - /** @see ShaderProgram#setUniform(int, Mat4f) */ + /** @see GlShaderProgram#setUniform(int, Mat4f) */ public void trySetUniform(int location, DhApiVec3i value) { if (location != -1) { this.setUniform(location, value); } } /** Requires a bound ShaderProgram. */ @@ -200,7 +200,7 @@ public class ShaderProgram GL32.glUniformMatrix4fv(location, false, buffer); } } - /** @see ShaderProgram#setUniform(int, Mat4f) */ + /** @see GlShaderProgram#setUniform(int, Mat4f) */ public void trySetUniform(int location, Mat4f value) { if (location != -1) { this.setUniform(location, value); } } /** @@ -215,7 +215,7 @@ public class ShaderProgram value.getBlue() / 256.0f, value.getAlpha() / 256.0f); } - /** @see ShaderProgram#setUniform(int, Color) */ + /** @see GlShaderProgram#setUniform(int, Color) */ public void trySetUniform(int location, Color value) { if (location != -1) { this.setUniform(location, value); } } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhDepthBufferFormat.java similarity index 71% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhDepthBufferFormat.java index 734f4bb25..8b2dc5dcb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhDepthBufferFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhDepthBufferFormat.java @@ -1,10 +1,10 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; import org.jetbrains.annotations.Nullable; import org.lwjgl.opengl.GL30C; import org.lwjgl.opengl.GL43C; -public enum EDhDepthBufferFormat +public enum EGlDhDepthBufferFormat { DEPTH(false), DEPTH16(false), @@ -19,43 +19,43 @@ public enum EDhDepthBufferFormat private final boolean combinedStencil; - EDhDepthBufferFormat(boolean combinedStencil) { this.combinedStencil = combinedStencil; } + EGlDhDepthBufferFormat(boolean combinedStencil) { this.combinedStencil = combinedStencil; } @Nullable - public static EDhDepthBufferFormat fromGlEnum(int glenum) + public static EGlDhDepthBufferFormat fromGlEnum(int glenum) { switch (glenum) { case GL30C.GL_DEPTH_COMPONENT: - return EDhDepthBufferFormat.DEPTH; + return EGlDhDepthBufferFormat.DEPTH; case GL30C.GL_DEPTH_COMPONENT16: - return EDhDepthBufferFormat.DEPTH16; + return EGlDhDepthBufferFormat.DEPTH16; case GL30C.GL_DEPTH_COMPONENT24: - return EDhDepthBufferFormat.DEPTH24; + return EGlDhDepthBufferFormat.DEPTH24; case GL30C.GL_DEPTH_COMPONENT32: - return EDhDepthBufferFormat.DEPTH32; + return EGlDhDepthBufferFormat.DEPTH32; case GL30C.GL_DEPTH_COMPONENT32F: - return EDhDepthBufferFormat.DEPTH32F; + return EGlDhDepthBufferFormat.DEPTH32F; case GL30C.GL_DEPTH_STENCIL: - return EDhDepthBufferFormat.DEPTH_STENCIL; + return EGlDhDepthBufferFormat.DEPTH_STENCIL; case GL30C.GL_DEPTH24_STENCIL8: - return EDhDepthBufferFormat.DEPTH24_STENCIL8; + return EGlDhDepthBufferFormat.DEPTH24_STENCIL8; case GL30C.GL_DEPTH32F_STENCIL8: - return EDhDepthBufferFormat.DEPTH32F_STENCIL8; + return EGlDhDepthBufferFormat.DEPTH32F_STENCIL8; default: return null; } } - public static EDhDepthBufferFormat fromGlEnumOrDefault(int glenum) + public static EGlDhDepthBufferFormat fromGlEnumOrDefault(int glenum) { - EDhDepthBufferFormat format = fromGlEnum(glenum); + EGlDhDepthBufferFormat format = fromGlEnum(glenum); if (format == null) { // yolo, just assume it's GL_DEPTH_COMPONENT - return EDhDepthBufferFormat.DEPTH; + return EGlDhDepthBufferFormat.DEPTH; } return format; } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhInternalTextureFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhInternalTextureFormat.java new file mode 100644 index 000000000..c37999e6c --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhInternalTextureFormat.java @@ -0,0 +1,131 @@ +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; + +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.EGlVersion; +import org.lwjgl.opengl.GL11C; +import org.lwjgl.opengl.GL30C; +import org.lwjgl.opengl.GL31C; + +import java.util.Locale; +import java.util.Optional; + +public enum EGlDhInternalTextureFormat +{ + RGBA(GL11C.GL_RGBA, EGlVersion.GL_11, EGlDhPixelFormat.RGBA), + + // 8-bit normalized + R8(GL30C.GL_R8, EGlVersion.GL_30, EGlDhPixelFormat.RED), + RG8(GL30C.GL_RG8, EGlVersion.GL_30, EGlDhPixelFormat.RG), + RGB8(GL11C.GL_RGB8, EGlVersion.GL_11, EGlDhPixelFormat.RGB), + RGBA8(GL11C.GL_RGBA8, EGlVersion.GL_11, EGlDhPixelFormat.RGBA), + + // 8-bit signed normalized + R8_SNORM(GL31C.GL_R8_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RED), + RG8_SNORM(GL31C.GL_RG8_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RG), + RGB8_SNORM(GL31C.GL_RGB8_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RGB), + RGBA8_SNORM(GL31C.GL_RGBA8_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RGBA), + + // 16-bit normalized + R16(GL30C.GL_R16, EGlVersion.GL_30, EGlDhPixelFormat.RED), + RG16(GL30C.GL_RG16, EGlVersion.GL_30, EGlDhPixelFormat.RG), + RGB16(GL11C.GL_RGB16, EGlVersion.GL_11, EGlDhPixelFormat.RGB), + RGBA16(GL11C.GL_RGBA16, EGlVersion.GL_11, EGlDhPixelFormat.RGBA), + + // 16-bit signed normalized + R16_SNORM(GL31C.GL_R16_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RED), + RG16_SNORM(GL31C.GL_RG16_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RG), + RGB16_SNORM(GL31C.GL_RGB16_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RGB), + RGBA16_SNORM(GL31C.GL_RGBA16_SNORM, EGlVersion.GL_31, EGlDhPixelFormat.RGBA), + + // 16-bit float + R16F(GL30C.GL_R16F, EGlVersion.GL_30, EGlDhPixelFormat.RED), + RG16F(GL30C.GL_RG16F, EGlVersion.GL_30, EGlDhPixelFormat.RG), + RGB16F(GL30C.GL_RGB16F, EGlVersion.GL_30, EGlDhPixelFormat.RGB), + RGBA16F(GL30C.GL_RGBA16F, EGlVersion.GL_30, EGlDhPixelFormat.RGBA), + + // 32-bit float + R32F(GL30C.GL_R32F, EGlVersion.GL_30, EGlDhPixelFormat.RED), + RG32F(GL30C.GL_RG32F, EGlVersion.GL_30, EGlDhPixelFormat.RG), + RGB32F(GL30C.GL_RGB32F, EGlVersion.GL_30, EGlDhPixelFormat.RGB), + RGBA32F(GL30C.GL_RGBA32F, EGlVersion.GL_30, EGlDhPixelFormat.RGBA), + + // 8-bit integer + R8I(GL30C.GL_R8I, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG8I(GL30C.GL_RG8I, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB8I(GL30C.GL_RGB8I, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA8I(GL30C.GL_RGBA8I, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // 8-bit unsigned integer + R8UI(GL30C.GL_R8UI, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG8UI(GL30C.GL_RG8UI, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB8UI(GL30C.GL_RGB8UI, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA8UI(GL30C.GL_RGBA8UI, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // 16-bit integer + R16I(GL30C.GL_R16I, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG16I(GL30C.GL_RG16I, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB16I(GL30C.GL_RGB16I, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA16I(GL30C.GL_RGBA16I, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // 16-bit unsigned integer + R16UI(GL30C.GL_R16UI, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG16UI(GL30C.GL_RG16UI, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB16UI(GL30C.GL_RGB16UI, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA16UI(GL30C.GL_RGBA16UI, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // 32-bit integer + R32I(GL30C.GL_R32I, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG32I(GL30C.GL_RG32I, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB32I(GL30C.GL_RGB32I, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA32I(GL30C.GL_RGBA32I, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // 32-bit unsigned integer + R32UI(GL30C.GL_R32UI, EGlVersion.GL_30, EGlDhPixelFormat.RED_INTEGER), + RG32UI(GL30C.GL_RG32UI, EGlVersion.GL_30, EGlDhPixelFormat.RG_INTEGER), + RGB32UI(GL30C.GL_RGB32UI, EGlVersion.GL_30, EGlDhPixelFormat.RGB_INTEGER), + RGBA32UI(GL30C.GL_RGBA32UI, EGlVersion.GL_30, EGlDhPixelFormat.RGBA_INTEGER), + + // Mixed + R3_G3_B2(GL11C.GL_R3_G3_B2, EGlVersion.GL_11, EGlDhPixelFormat.RGB), + RGB5_A1(GL11C.GL_RGB5_A1, EGlVersion.GL_11, EGlDhPixelFormat.RGBA), + RGB10_A2(GL11C.GL_RGB10_A2, EGlVersion.GL_11, EGlDhPixelFormat.RGBA), + R11F_G11F_B10F(GL30C.GL_R11F_G11F_B10F, EGlVersion.GL_30, EGlDhPixelFormat.RGB), + RGB9_E5(GL30C.GL_RGB9_E5, EGlVersion.GL_30, EGlDhPixelFormat.RGB); + + + + private final int glFormat; + private final EGlVersion minimumGlVersion; + private final EGlDhPixelFormat expectedPixelFormat; + + + + EGlDhInternalTextureFormat(int glFormat, EGlVersion minimumGlVersion, EGlDhPixelFormat expectedPixelFormat) + { + this.glFormat = glFormat; + this.minimumGlVersion = minimumGlVersion; + this.expectedPixelFormat = expectedPixelFormat; + } + + + + public static Optional fromString(String name) + { + try + { + return Optional.of(EGlDhInternalTextureFormat.valueOf(name.toUpperCase(Locale.US))); + } + catch (IllegalArgumentException e) + { + return Optional.empty(); + } + } + + public int getGlFormat() { return this.glFormat; } + + public EGlDhPixelFormat getPixelFormat() { return this.expectedPixelFormat; } + + public EGlVersion getMinimumGlVersion() { return this.minimumGlVersion; } + + + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelFormat.java similarity index 76% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelFormat.java index 8427e62ea..989575037 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelFormat.java @@ -1,5 +1,6 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.EGlVersion; import org.lwjgl.opengl.GL11C; import org.lwjgl.opengl.GL12C; import org.lwjgl.opengl.GL30C; @@ -7,7 +8,7 @@ import org.lwjgl.opengl.GL30C; import java.util.Locale; import java.util.Optional; -public enum EDhPixelFormat +public enum EGlDhPixelFormat { RED(GL11C.GL_RED, EGlVersion.GL_11, false), RG(GL30C.GL_RG, EGlVersion.GL_30, false), @@ -30,7 +31,7 @@ public enum EDhPixelFormat - EDhPixelFormat(int glFormat, EGlVersion minimumGlVersion, boolean isInteger) + EGlDhPixelFormat(int glFormat, EGlVersion minimumGlVersion, boolean isInteger) { this.glFormat = glFormat; this.minimumGlVersion = minimumGlVersion; @@ -39,11 +40,11 @@ public enum EDhPixelFormat - public static Optional fromString(String name) + public static Optional fromString(String name) { try { - return Optional.of(EDhPixelFormat.valueOf(name.toUpperCase(Locale.US))); + return Optional.of(EGlDhPixelFormat.valueOf(name.toUpperCase(Locale.US))); } catch (IllegalArgumentException e) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelType.java similarity index 82% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelType.java index 5d3c5d176..0dd223131 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/EDhPixelType.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/EGlDhPixelType.java @@ -1,5 +1,6 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; +import com.seibel.distanthorizons.common.render.openGl.glObject.enums.EGlVersion; import org.lwjgl.opengl.GL11C; import org.lwjgl.opengl.GL12C; import org.lwjgl.opengl.GL30C; @@ -7,7 +8,7 @@ import org.lwjgl.opengl.GL30C; import java.util.Locale; import java.util.Optional; -public enum EDhPixelType +public enum EGlDhPixelType { BYTE(GL11C.GL_BYTE, EGlVersion.GL_11), SHORT(GL11C.GL_SHORT, EGlVersion.GL_11), @@ -37,7 +38,7 @@ public enum EDhPixelType - EDhPixelType(int glFormat, EGlVersion minimumGlVersion) + EGlDhPixelType(int glFormat, EGlVersion minimumGlVersion) { this.glFormat = glFormat; this.minimumGlVersion = minimumGlVersion; @@ -45,11 +46,11 @@ public enum EDhPixelType - public static Optional fromString(String name) + public static Optional fromString(String name) { try { - return Optional.of(EDhPixelType.valueOf(name.toUpperCase(Locale.US))); + return Optional.of(EGlDhPixelType.valueOf(name.toUpperCase(Locale.US))); } catch (IllegalArgumentException e) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhColorTexture.java similarity index 82% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhColorTexture.java index 4b4a8cf1b..226022126 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DhColorTexture.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhColorTexture.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import org.joml.Vector2i; @@ -8,14 +8,14 @@ import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; -public class DhColorTexture +public class GlDhColorTexture { private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; - private final EDhInternalTextureFormat internalFormat; - private final EDhPixelFormat format; - private final EDhPixelType type; + private final EGlDhInternalTextureFormat internalFormat; + private final EGlDhPixelFormat format; + private final EGlDhPixelType type; private int width; private int height; @@ -31,7 +31,7 @@ public class DhColorTexture // constructor // //=============// - public DhColorTexture(Builder builder) + public GlDhColorTexture(Builder builder) { this.isValid = true; @@ -91,7 +91,7 @@ public class DhColorTexture this.resizeTexture(this.id, width, height); } - public EDhInternalTextureFormat getInternalFormat() { return this.internalFormat; } + public EGlDhInternalTextureFormat getInternalFormat() { return this.internalFormat; } public int getTextureId() { @@ -130,18 +130,18 @@ public class DhColorTexture public static class Builder { - private EDhInternalTextureFormat internalFormat = EDhInternalTextureFormat.RGBA8; + private EGlDhInternalTextureFormat internalFormat = EGlDhInternalTextureFormat.RGBA8; private int width = 0; private int height = 0; - private EDhPixelFormat format = EDhPixelFormat.RGBA; - private EDhPixelType type = EDhPixelType.UNSIGNED_BYTE; + private EGlDhPixelFormat format = EGlDhPixelFormat.RGBA; + private EGlDhPixelType type = EGlDhPixelType.UNSIGNED_BYTE; private Builder() { // No-op } - public Builder setInternalFormat(EDhInternalTextureFormat format) + public Builder setInternalFormat(EGlDhInternalTextureFormat format) { this.internalFormat = format; return this; @@ -165,19 +165,19 @@ public class DhColorTexture return this; } - public Builder setPixelFormat(EDhPixelFormat pixelFormat) + public Builder setPixelFormat(EGlDhPixelFormat pixelFormat) { this.format = pixelFormat; return this; } - public Builder setPixelType(EDhPixelType pixelType) + public Builder setPixelType(EGlDhPixelType pixelType) { this.type = pixelType; return this; } - public DhColorTexture build() { return new DhColorTexture(this); } + public GlDhColorTexture build() { return new GlDhColorTexture(this); } } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhDepthTexture.java similarity index 83% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhDepthTexture.java index f687f7941..0de544062 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/texture/DHDepthTexture.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/texture/GlDhDepthTexture.java @@ -1,4 +1,4 @@ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.texture; +package com.seibel.distanthorizons.common.render.openGl.glObject.texture; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import org.lwjgl.opengl.GL11C; @@ -7,13 +7,13 @@ import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; -public class DHDepthTexture +public class GlDhDepthTexture { private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; private int id; - public DHDepthTexture(int width, int height, EDhDepthBufferFormat format) + public GlDhDepthTexture(int width, int height, EGlDhDepthBufferFormat format) { this.id = GL43C.glGenTextures(); @@ -32,9 +32,9 @@ public class DHDepthTexture } // For internal use by Iris for copying data. Do not use this in DH. - public DHDepthTexture(int id) { this.id = id; } + public GlDhDepthTexture(int id) { this.id = id; } - public void resize(int width, int height, EDhDepthBufferFormat format) + public void resize(int width, int height, EGlDhDepthBufferFormat format) { GL43C.glBindTexture(GL43C.GL_TEXTURE_2D, this.getTextureId()); GL43C.glTexImage2D(GL11C.GL_TEXTURE_2D, 0, format.getGlInternalFormat(), width, height, 0, diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlAbstractVertexAttribute.java similarity index 83% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlAbstractVertexAttribute.java index 224ad8b0b..a599dc96d 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/AbstractVertexAttribute.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlAbstractVertexAttribute.java @@ -17,18 +17,18 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; +package com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLProxy; import org.lwjgl.opengl.GL32; /** * Base for binding/unbinding Vertex Attribute objects (VAO's). * - * @see VertexAttributePostGL43 - * @see VertexAttributePreGL43 + * @see GlVertexAttributePostGL43 + * @see GlVertexAttributePreGL43 */ -public abstract class AbstractVertexAttribute +public abstract class GlAbstractVertexAttribute { /** Stores the handle of the AbstractVertexAttribute. */ public final int id; @@ -40,21 +40,21 @@ public abstract class AbstractVertexAttribute //==============// // This will bind AbstractVertexAttribute - protected AbstractVertexAttribute() + protected GlAbstractVertexAttribute() { this.id = GL32.glGenVertexArrays(); GL32.glBindVertexArray(this.id); } - public static AbstractVertexAttribute create() + public static GlAbstractVertexAttribute create() { if (GLProxy.getInstance().vertexAttributeBufferBindingSupported) { - return new VertexAttributePostGL43(); + return new GlVertexAttributePostGL43(); } else { - return new VertexAttributePreGL43(); + return new GlVertexAttributePreGL43(); } } @@ -85,7 +85,7 @@ public abstract class AbstractVertexAttribute /** Requires both AbstractVertexAttribute to be bound */ public abstract void unbindBuffersFromBindingPoint(int bindingPoint); /** Requires both AbstractVertexAttribute to be bound */ - public abstract void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute); + public abstract void setVertexAttribute(int bindingPoint, int attributeIndex, GlVertexPointer attribute); /** Requires both AbstractVertexAttribute to be bound */ public abstract void completeAndCheck(int expectedStrideSize); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePostGL43.java similarity index 93% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePostGL43.java index 7733fbf50..9a2328212 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePostGL43.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePostGL43.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; +package com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -33,7 +33,7 @@ import org.lwjgl.opengl.GL43; * Since I no longer need to implement binding points, I also no * longer needs to keep track of Pointers. */ -public final class VertexAttributePostGL43 extends AbstractVertexAttribute +public final class GlVertexAttributePostGL43 extends GlAbstractVertexAttribute { private static final DhLogger LOGGER = new DhLoggerBuilder() .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) @@ -50,8 +50,8 @@ public final class VertexAttributePostGL43 extends AbstractVertexAttribute // constructor // //=============// - /** This will bind the {@link AbstractVertexAttribute} */ - public VertexAttributePostGL43() + /** This will bind the {@link GlAbstractVertexAttribute} */ + public GlVertexAttributePostGL43() { super(); // also bind AbstractVertexAttribute } @@ -110,7 +110,7 @@ public final class VertexAttributePostGL43 extends AbstractVertexAttribute /** Requires AbstractVertexAttribute to be bound */ @Override - public void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute) + public void setVertexAttribute(int bindingPoint, int attributeIndex, GlVertexPointer attribute) { if (attribute.useInteger) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePreGL43.java similarity index 90% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePreGL43.java index 5c18b2b13..49ded30cc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/glObject/vertexAttribute/VertexAttributePreGL43.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexAttributePreGL43.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute; +package com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute; import java.util.ArrayList; import java.util.Iterator; @@ -30,7 +30,7 @@ import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; import org.lwjgl.opengl.GL32; -public final class VertexAttributePreGL43 extends AbstractVertexAttribute +public final class GlVertexAttributePreGL43 extends GlAbstractVertexAttribute { private static final DhLogger LOGGER = new DhLoggerBuilder() .fileLevelConfig(Config.Common.Logging.logRendererGLEventToFile) @@ -42,11 +42,11 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute // happen every frame, and the speed directly affects fps int strideSize = 0; int[][] bindingPointsToIndex; - VertexPointer[] pointers; + GlVertexPointer[] pointers; int[] pointersOffset; TreeMap> bindingPointsToIndexBuilder; - ArrayList pointersBuilder; + ArrayList pointersBuilder; @@ -54,8 +54,8 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute // constructor // //=============// - /** This will bind the {@link AbstractVertexAttribute} */ - public VertexAttributePreGL43() + /** This will bind the {@link GlAbstractVertexAttribute} */ + public GlVertexAttributePreGL43() { super(); // also bind AbstractVertexAttribute this.bindingPointsToIndexBuilder = new TreeMap<>(); @@ -79,7 +79,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute for (int i = 0; i < this.pointers.length; i++) { - VertexPointer pointer = this.pointers[i]; + GlVertexPointer pointer = this.pointers[i]; if (pointer == null) { continue; @@ -111,7 +111,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute for (int bindingPointIndex : bindingPointIndexes) { - VertexPointer pointer = this.pointers[bindingPointIndex]; + GlVertexPointer pointer = this.pointers[bindingPointIndex]; if (pointer == null) { continue; @@ -166,7 +166,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute /** Requires AbstractVertexAttribute to be bound */ @Override - public void setVertexAttribute(int bindingPoint, int attributeIndex, VertexPointer attribute) + public void setVertexAttribute(int bindingPoint, int attributeIndex, GlVertexPointer attribute) { TreeSet intArray = this.bindingPointsToIndexBuilder.computeIfAbsent(bindingPoint, k -> new TreeSet<>()); intArray.add(attributeIndex); @@ -203,7 +203,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute } }); - this.pointers = this.pointersBuilder.toArray(new VertexPointer[this.pointersBuilder.size()]); + this.pointers = this.pointersBuilder.toArray(new GlVertexPointer[this.pointersBuilder.size()]); this.pointersOffset = new int[this.pointers.length]; this.pointersBuilder = null; // Release the builder this.bindingPointsToIndexBuilder = null; // Release the builder @@ -212,7 +212,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute int currentOffset = 0; for (int i = 0; i < this.pointers.length; i++) { - VertexPointer pointer = this.pointers[i]; + GlVertexPointer pointer = this.pointers[i]; if (pointer == null) { LOGGER.warn("Vertex Attribute index " + i + " is not set! No index should be skipped normally!"); @@ -236,7 +236,7 @@ public final class VertexAttributePreGL43 extends AbstractVertexAttribute for (int i = 0; i < this.pointers.length; i++) { - VertexPointer pointer = this.pointers[i]; + GlVertexPointer pointer = this.pointers[i]; if (pointer == null) { LOGGER.debug(i + ": Null!!!!"); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexPointer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexPointer.java new file mode 100644 index 000000000..6fca75b10 --- /dev/null +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/glObject/vertexAttribute/GlVertexPointer.java @@ -0,0 +1,72 @@ +/* + * This file is part of the Distant Horizons mod + * licensed under the GNU LGPL v3 License. + * + * Copyright (C) 2020 James Seibel + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + */ + +package com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute; + +import com.seibel.distanthorizons.coreapi.util.MathUtil; +import org.lwjgl.opengl.GL32; + +public final class GlVertexPointer +{ + public final int elementCount; + public final int glType; + public final boolean normalized; + public final int byteSize; + public final boolean useInteger; + + + + // basic constructors // + + public GlVertexPointer(int elementCount, int glType, boolean normalized, int byteSize, boolean useInteger) + { + this.elementCount = elementCount; + this.glType = glType; + this.normalized = normalized; + this.byteSize = byteSize; + this.useInteger = useInteger; + } + public GlVertexPointer(int elementCount, int glType, boolean normalized, int byteSize) + { + this(elementCount, glType, normalized, byteSize, false); + } + private static int _align(int bytes) { return MathUtil.ceilDiv(bytes, 4) * 4; } + + + + // named constructors // + + public static GlVertexPointer addFloatPointer(boolean normalized) { return new GlVertexPointer(1, GL32.GL_FLOAT, normalized, Float.BYTES); } + public static GlVertexPointer addVec2Pointer(boolean normalized) { return new GlVertexPointer(2, GL32.GL_FLOAT, normalized, Float.BYTES * 2); } + public static GlVertexPointer addVec3Pointer(boolean normalized) { return new GlVertexPointer(3, GL32.GL_FLOAT, normalized, Float.BYTES * 3); } + public static GlVertexPointer addVec4Pointer(boolean normalized) { return new GlVertexPointer(4, GL32.GL_FLOAT, normalized, Float.BYTES * 4); } + /** Always aligned to 4 bytes */ + public static GlVertexPointer addUnsignedBytePointer(boolean normalized, boolean useInteger) { return new GlVertexPointer(1, GL32.GL_UNSIGNED_BYTE, normalized, 4, useInteger); } + /** aligned to 4 bytes */ + public static GlVertexPointer addUnsignedBytesPointer(int elementCount, boolean normalized, boolean useInteger) + { return new GlVertexPointer(elementCount, GL32.GL_UNSIGNED_BYTE, normalized, _align(elementCount), useInteger); } + public static GlVertexPointer addUnsignedShortsPointer(int elementCount, boolean normalized, boolean useInteger) + { return new GlVertexPointer(elementCount, GL32.GL_UNSIGNED_SHORT, normalized, _align(elementCount * 2), useInteger); } + public static GlVertexPointer addShortsPointer(int elementCount, boolean normalized, boolean useInteger) { return new GlVertexPointer(elementCount, GL32.GL_SHORT, normalized, _align(elementCount * 2), useInteger); } + public static GlVertexPointer addIntPointer(boolean normalized, boolean useInteger) { return new GlVertexPointer(1, GL32.GL_INT, normalized, 4, useInteger); } + public static GlVertexPointer addIVec2Pointer(boolean normalized, boolean useInteger) { return new GlVertexPointer(2, GL32.GL_INT, normalized, 8, useInteger); } + public static GlVertexPointer addIVec3Pointer(boolean normalized, boolean useInteger) { return new GlVertexPointer(3, GL32.GL_INT, normalized, 12, useInteger); } + public static GlVertexPointer addIVec4Pointer(boolean normalized, boolean useInteger) { return new GlVertexPointer(4, GL32.GL_INT, normalized, 16, useInteger); } + +} diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/GlScreenQuad.java similarity index 78% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/GlScreenQuad.java index f42223b94..5441d59d9 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ScreenQuad.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/GlScreenQuad.java @@ -17,12 +17,12 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing; +package com.seibel.distanthorizons.common.render.openGl.postProcessing; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; import org.lwjgl.opengl.GL32; import org.lwjgl.system.MemoryUtil; @@ -32,9 +32,9 @@ import java.nio.ByteBuffer; * Renders a full-screen textured quad to the screen. * Used in composite / deferred rendering (IE fog). */ -public class ScreenQuad +public class GlScreenQuad { - public static ScreenQuad INSTANCE = new ScreenQuad(); + public static GlScreenQuad INSTANCE = new GlScreenQuad(); private static final float[] BOX_VERTICES = { -1, -1, @@ -47,7 +47,7 @@ public class ScreenQuad }; private GLVertexBuffer boxBuffer; - private AbstractVertexAttribute va; + private GlAbstractVertexAttribute va; private boolean init = false; @@ -57,18 +57,18 @@ public class ScreenQuad //=============// //region - private ScreenQuad() { } + private GlScreenQuad() { } public void init() { if (this.init) return; this.init = true; - this.va = AbstractVertexAttribute.create(); + this.va = GlAbstractVertexAttribute.create(); this.va.bind(); // Pos - this.va.setVertexAttribute(0, 0, VertexPointer.addVec2Pointer(false)); + this.va.setVertexAttribute(0, 0, GlVertexPointer.addVec2Pointer(false)); this.va.completeAndCheck(Float.BYTES * 2); // Framebuffer diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java similarity index 79% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java index 67a14ff8a..7407d0379 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/apply/DhApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java @@ -17,25 +17,24 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.apply; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLState; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.logging.DhLogger; import org.lwjgl.opengl.GL32; /** * Copies {@link com.seibel.distanthorizons.core.render.renderer.LodRenderer}'s currently active color and depth texture to Minecraft's framebuffer. */ -public class DhApplyShader extends AbstractShaderRenderer +public class GlDhApplyShader extends GlAbstractShaderRenderer { - public static DhApplyShader INSTANCE = new DhApplyShader(); + public static GlDhApplyShader INSTANCE = new GlDhApplyShader(); private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -52,12 +51,12 @@ public class DhApplyShader extends AbstractShaderRenderer //=======// //region - private DhApplyShader() { } + private GlDhApplyShader() { } @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/apply.frag", "vPosition" @@ -115,17 +114,17 @@ public class DhApplyShader extends AbstractShaderRenderer //GLMC.glBlendFunc(GL32.GL_ONE, GL32.GL_ONE_MINUS_SRC_ALPHA); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); // Copy to MC's framebuffer GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, targetFrameBuffer); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } // everything's been restored, except at this point the MC framebuffer should now be used instead GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, targetFrameBuffer); @@ -139,7 +138,7 @@ public class DhApplyShader extends AbstractShaderRenderer return; } - int dhFrameBufferId = OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); + int dhFrameBufferId = GlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); if (dhFrameBufferId == -1) { return; @@ -163,11 +162,11 @@ public class DhApplyShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveColorTextureId()); GL32.glUniform1i(this.gDhColorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 1); @@ -177,7 +176,7 @@ public class DhApplyShader extends AbstractShaderRenderer // Copy to MC's texture via MC's framebuffer GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, dhFrameBufferId); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } // everything's been restored, except at this point the MC framebuffer should now be used instead GLMC.glBindFramebuffer(GL32.GL_FRAMEBUFFER, mcFrameBufferId); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java similarity index 79% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java index 9dfb15879..9e7c47ba1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java @@ -17,12 +17,12 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fade; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import org.lwjgl.opengl.GL32; @@ -30,12 +30,12 @@ import org.lwjgl.opengl.GL32; * Draws the Fade texture onto Minecraft's FrameBuffer.

* * See Also:
- * {@link VanillaFadeRenderer} - Parent to this shader.
- * {@link VanillaFadeShader} - draws the Fade texture.
+ * {@link GlVanillaFadeRenderer} - Parent to this shader.
+ * {@link GlDhVanillaFadeShader} - draws the Fade texture.
*/ -public class DhFarFadeApplyShader extends AbstractShaderRenderer +public class GlDhFarFadeApplyShader extends GlAbstractShaderRenderer { - public static DhFarFadeApplyShader INSTANCE = new DhFarFadeApplyShader(); + public static GlDhFarFadeApplyShader INSTANCE = new GlDhFarFadeApplyShader(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -58,7 +58,7 @@ public class DhFarFadeApplyShader extends AbstractShaderRenderer @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/fade/apply.frag", "vPosition" @@ -105,7 +105,7 @@ public class DhFarFadeApplyShader extends AbstractShaderRenderer GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, this.readFramebuffer); GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, this.drawFramebuffer); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); GLMC.enableDepthTest(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeRenderer.java similarity index 75% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeRenderer.java index cb3800aa8..f9a7d7960 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeRenderer.java @@ -17,10 +17,9 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fade; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; @@ -34,15 +33,15 @@ import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; /** - * Handles fading MC and DH together via {@link DhFarFadeShader} and {@link DhFarFadeApplyShader}.

+ * Handles fading MC and DH together via {@link GlDhFarFadeShader} and {@link GlDhFarFadeApplyShader}.

* - * {@link DhFarFadeShader} - draws the Fade to a texture.
- * {@link DhFarFadeApplyShader} - draws the Fade texture to DH's framebuffer.
+ * {@link GlDhFarFadeShader} - draws the Fade to a texture.
+ * {@link GlDhFarFadeApplyShader} - draws the Fade texture to DH's framebuffer.
*/ -public class DhFarFadeRenderer implements IDhFarFadeRenderer +public class GlDhFarFadeRenderer implements IDhFarFadeRenderer { - public static DhFarFadeRenderer INSTANCE = new DhFarFadeRenderer(); + public static GlDhFarFadeRenderer INSTANCE = new GlDhFarFadeRenderer(); private static final DhLogger LOGGER = new DhLoggerBuilder().build(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); @@ -64,15 +63,15 @@ public class DhFarFadeRenderer implements IDhFarFadeRenderer //=============// //region - private DhFarFadeRenderer() { } + private GlDhFarFadeRenderer() { } public void init() { if (this.init) return; this.init = true; - DhFarFadeShader.INSTANCE.init(); - DhFarFadeApplyShader.INSTANCE.init(); + GlDhFarFadeShader.INSTANCE.init(); + GlDhFarFadeApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -138,16 +137,16 @@ public class DhFarFadeRenderer implements IDhFarFadeRenderer } - DhFarFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; - DhFarFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); - DhFarFadeShader.INSTANCE.render(renderParams); + GlDhFarFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; + GlDhFarFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); + GlDhFarFadeShader.INSTANCE.render(renderParams); //profiler.popPush("Fade Apply"); - DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; - DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; - DhFarFadeApplyShader.INSTANCE.drawFramebuffer = OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); - DhFarFadeApplyShader.INSTANCE.render(renderParams); + GlDhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + GlDhFarFadeApplyShader.INSTANCE.readFramebuffer = GlDhFarFadeShader.INSTANCE.frameBuffer; + GlDhFarFadeApplyShader.INSTANCE.drawFramebuffer = GlDhMetaRenderer.INSTANCE.getActiveFramebufferId(); + GlDhFarFadeApplyShader.INSTANCE.render(renderParams); } catch (Exception e) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java similarity index 84% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java index e3d854937..62f99ea42 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/DhFarFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java @@ -17,25 +17,24 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fade; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -public class DhFarFadeShader extends AbstractShaderRenderer +public class GlDhFarFadeShader extends GlAbstractShaderRenderer { - public static DhFarFadeShader INSTANCE = new DhFarFadeShader(); + public static GlDhFarFadeShader INSTANCE = new GlDhFarFadeShader(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -64,12 +63,12 @@ public class DhFarFadeShader extends AbstractShaderRenderer // constructor // //=============// - public DhFarFadeShader() { } + public GlDhFarFadeShader() { } @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/fade/dhFade.frag", "vPosition" @@ -130,8 +129,8 @@ public class DhFarFadeShader extends AbstractShaderRenderer @Override protected void onRender() { - int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); + int depthTextureId = GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = GlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) @@ -162,7 +161,7 @@ public class DhFarFadeShader extends AbstractShaderRenderer GL32.glUniform1i(this.uDhColorTexture, 2); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java similarity index 88% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java index bd4ea32db..bd0e444c4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java @@ -17,26 +17,25 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fade; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import com.seibel.distanthorizons.core.util.math.Mat4f; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -public class VanillaFadeShader extends AbstractShaderRenderer +public class GlDhVanillaFadeShader extends GlAbstractShaderRenderer { - public static VanillaFadeShader INSTANCE = new VanillaFadeShader(); + public static GlDhVanillaFadeShader INSTANCE = new GlDhVanillaFadeShader(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -72,12 +71,12 @@ public class VanillaFadeShader extends AbstractShaderRenderer //=============// //region - public VanillaFadeShader() { } + public GlDhVanillaFadeShader() { } @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/fade/vanillaFade.frag", "vPosition" @@ -167,8 +166,8 @@ public class VanillaFadeShader extends AbstractShaderRenderer @Override protected void onRender() { - int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); - int colorTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); + int depthTextureId = GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); + int colorTextureId = GlDhMetaRenderer.INSTANCE.getActiveColorTextureId(); if (depthTextureId == -1 || colorTextureId == -1) @@ -202,7 +201,7 @@ public class VanillaFadeShader extends AbstractShaderRenderer GL32.glUniform1i(this.uDhColorTexture, 3); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlVanillaFadeRenderer.java similarity index 76% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlVanillaFadeRenderer.java index 057a0b599..c8c9524c5 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fade/VanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlVanillaFadeRenderer.java @@ -17,10 +17,10 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fade; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fade; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -35,14 +35,14 @@ import org.lwjgl.opengl.GL32; import java.nio.ByteBuffer; /** - * Handles fading MC and DH together via {@link VanillaFadeShader} and {@link DhFarFadeApplyShader}.

+ * Handles fading MC and DH together via {@link GlDhVanillaFadeShader} and {@link GlDhFarFadeApplyShader}.

* - * {@link VanillaFadeShader} - draws the Fade to a texture.
- * {@link DhFarFadeApplyShader} - draws the Fade texture to MC's FrameBuffer.
+ * {@link GlDhVanillaFadeShader} - draws the Fade to a texture.
+ * {@link GlDhFarFadeApplyShader} - draws the Fade texture to MC's FrameBuffer.
*/ -public class VanillaFadeRenderer implements IDhVanillaFadeRenderer +public class GlVanillaFadeRenderer implements IDhVanillaFadeRenderer { - public static VanillaFadeRenderer INSTANCE = new VanillaFadeRenderer(); + public static GlVanillaFadeRenderer INSTANCE = new GlVanillaFadeRenderer(); private static final DhLogger LOGGER = new DhLoggerBuilder().build(); @@ -66,15 +66,15 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer //=============// //region - private VanillaFadeRenderer() { } + private GlVanillaFadeRenderer() { } public void init() { if (this.init) return; this.init = true; - VanillaFadeShader.INSTANCE.init(); - DhFarFadeApplyShader.INSTANCE.init(); + GlDhVanillaFadeShader.INSTANCE.init(); + GlDhFarFadeApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -124,7 +124,7 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer @Override public void render(RenderParams renderParams) { - int depthTextureId = OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); + int depthTextureId = GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId(); if (depthTextureId == -1) { // the renderer hasn't been set up yet @@ -156,10 +156,10 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer } - VanillaFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; - VanillaFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); - VanillaFadeShader.INSTANCE.setLevelMaxHeight(renderParams.clientLevelWrapper.getMaxHeight()); - VanillaFadeShader.INSTANCE.render(renderParams); + GlDhVanillaFadeShader.INSTANCE.frameBuffer = this.fadeFramebuffer; + GlDhVanillaFadeShader.INSTANCE.setProjectionMatrix(renderParams.mcModelViewMatrix, renderParams.mcProjectionMatrix); + GlDhVanillaFadeShader.INSTANCE.setLevelMaxHeight(renderParams.clientLevelWrapper.getMaxHeight()); + GlDhVanillaFadeShader.INSTANCE.render(renderParams); // Applying the fade texture is only needed if MC is drawing to their own frame buffer, // otherwise we can directly render to their texture @@ -167,10 +167,10 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer { profiler.popPush("Vanilla Fade Apply"); - DhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; - DhFarFadeApplyShader.INSTANCE.readFramebuffer = DhFarFadeShader.INSTANCE.frameBuffer; - DhFarFadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); - DhFarFadeApplyShader.INSTANCE.render(renderParams); + GlDhFarFadeApplyShader.INSTANCE.fadeTexture = this.fadeTexture; + GlDhFarFadeApplyShader.INSTANCE.readFramebuffer = GlDhFarFadeShader.INSTANCE.frameBuffer; + GlDhFarFadeApplyShader.INSTANCE.drawFramebuffer = MC_RENDER.getTargetFramebuffer(); + GlDhFarFadeApplyShader.INSTANCE.render(renderParams); } profiler.pop(); @@ -192,8 +192,8 @@ public class VanillaFadeRenderer implements IDhVanillaFadeRenderer public void free() { - VanillaFadeShader.INSTANCE.free(); - DhFarFadeApplyShader.INSTANCE.free(); + GlDhVanillaFadeShader.INSTANCE.free(); + GlDhFarFadeApplyShader.INSTANCE.free(); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java similarity index 72% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java index e1f6c8308..4db8c0b6b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java @@ -17,14 +17,13 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fog; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import org.lwjgl.opengl.GL32; @@ -32,12 +31,12 @@ import org.lwjgl.opengl.GL32; * Draws the Fog texture onto DH's FrameBuffer.

* * See Also:
- * {@link DhFogRenderer} - Parent to this shader.
- * {@link FogShader} - draws the Fog texture.
+ * {@link GlDhFogRenderer} - Parent to this shader.
+ * {@link GlDhFogShader} - draws the Fog texture.
*/ -public class FogApplyShader extends AbstractShaderRenderer +public class GlDhFogApplyShader extends GlAbstractShaderRenderer { - public static FogApplyShader INSTANCE = new FogApplyShader(); + public static GlDhFogApplyShader INSTANCE = new GlDhFogApplyShader(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -57,7 +56,7 @@ public class FogApplyShader extends AbstractShaderRenderer @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/fog/apply.frag", "vPosition" @@ -83,7 +82,7 @@ public class FogApplyShader extends AbstractShaderRenderer GL32.glUniform1i(this.colorTextureUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.depthTextureUniform, 1); } @@ -108,10 +107,10 @@ public class FogApplyShader extends AbstractShaderRenderer // apply the rendered Fog to DH's framebuffer - GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, FogShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, GlDhFogShader.INSTANCE.frameBuffer); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, GlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, 0); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogRenderer.java similarity index 79% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogRenderer.java index 03dac4501..dd54a20f0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/DhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogRenderer.java @@ -17,10 +17,9 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fog; -import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.render.RenderParams; @@ -32,14 +31,14 @@ import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; /** - * Handles adding SSAO via {@link FogShader} and {@link FogApplyShader}.

+ * Handles adding SSAO via {@link GlDhFogShader} and {@link GlDhFogApplyShader}.

* - * {@link FogShader} - draws the Fog to a texture.
- * {@link FogApplyShader} - draws the Fog texture to DH's FrameBuffer.
+ * {@link GlDhFogShader} - draws the Fog to a texture.
+ * {@link GlDhFogApplyShader} - draws the Fog texture to DH's FrameBuffer.
*/ -public class DhFogRenderer implements IDhFogRenderer +public class GlDhFogRenderer implements IDhFogRenderer { - public static DhFogRenderer INSTANCE = new DhFogRenderer(); + public static GlDhFogRenderer INSTANCE = new GlDhFogRenderer(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -59,15 +58,15 @@ public class DhFogRenderer implements IDhFogRenderer // constructor // //=============// - private DhFogRenderer() { } + private GlDhFogRenderer() { } public void init() { if (this.init) return; this.init = true; - FogShader.INSTANCE.init(); - FogApplyShader.INSTANCE.init(); + GlDhFogShader.INSTANCE.init(); + GlDhFogApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -126,12 +125,12 @@ public class DhFogRenderer implements IDhFogRenderer this.createFramebuffer(width, height); } - FogShader.INSTANCE.frameBuffer = this.fogFramebuffer; - FogShader.INSTANCE.setProjectionMatrix(renderParams.dhMvmProjMatrix); - FogShader.INSTANCE.render(renderParams); + GlDhFogShader.INSTANCE.frameBuffer = this.fogFramebuffer; + GlDhFogShader.INSTANCE.setProjectionMatrix(renderParams.dhMvmProjMatrix); + GlDhFogShader.INSTANCE.render(renderParams); - FogApplyShader.INSTANCE.fogTexture = this.fogTexture; - FogApplyShader.INSTANCE.render(renderParams); + GlDhFogApplyShader.INSTANCE.fogTexture = this.fogTexture; + GlDhFogApplyShader.INSTANCE.render(renderParams); } } @@ -146,8 +145,8 @@ public class DhFogRenderer implements IDhFogRenderer public void free() { - FogShader.INSTANCE.free(); - FogApplyShader.INSTANCE.free(); + GlDhFogShader.INSTANCE.free(); + GlDhFogApplyShader.INSTANCE.free(); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java similarity index 93% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java index 7bc413807..c176a07bf 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/fog/FogShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java @@ -17,20 +17,19 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.fog; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.fog; import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogColorMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogDirection; import com.seibel.distanthorizons.api.enums.rendering.EDhApiHeightFogMixMode; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.LodUtil; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftClientWrapper; @@ -40,9 +39,9 @@ import org.lwjgl.opengl.GL32; import java.awt.*; -public class FogShader extends AbstractShaderRenderer +public class GlDhFogShader extends GlAbstractShaderRenderer { - public static final FogShader INSTANCE = new FogShader(); + public static final GlDhFogShader INSTANCE = new GlDhFogShader(); private static final IMinecraftClientWrapper MC = SingletonInjector.INSTANCE.get(IMinecraftClientWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -104,12 +103,12 @@ public class FogShader extends AbstractShaderRenderer //=============// //region - public FogShader() { } + public GlDhFogShader() { } @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/fog/fog.frag", "vPosition" @@ -277,7 +276,7 @@ public class FogShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.uDepthMap, 0); // this is necessary for MC 1.16 (IE Legacy OpenGL) @@ -293,7 +292,7 @@ public class FogShader extends AbstractShaderRenderer } - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java similarity index 77% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java index ac49b12ca..18a97f29a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java @@ -17,14 +17,13 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.ssao; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.RenderUtil; import org.lwjgl.opengl.GL32; @@ -33,12 +32,12 @@ import org.lwjgl.opengl.GL32; * Draws the SSAO texture onto DH's FrameBuffer.

* * See Also:
- * {@link DhSSAORenderer} - Parent to this shader.
- * {@link SSAOShader} - draws the SSAO texture.
+ * {@link GlDhSSAORenderer} - Parent to this shader.
+ * {@link GlDhSSAOShader} - draws the SSAO texture.
*/ -public class SSAOApplyShader extends AbstractShaderRenderer +public class GlDhSSAOApplyShader extends GlAbstractShaderRenderer { - public static SSAOApplyShader INSTANCE = new SSAOApplyShader(); + public static GlDhSSAOApplyShader INSTANCE = new GlDhSSAOApplyShader(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -62,7 +61,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/ssao/apply.frag", "vPosition" @@ -87,7 +86,7 @@ public class SSAOApplyShader extends AbstractShaderRenderer protected void onApplyUniforms(RenderParams renderParams) { GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); GL32.glUniform1i(this.gDepthMapUniform, 0); GLMC.glActiveTexture(GL32.GL_TEXTURE1); @@ -135,11 +134,11 @@ public class SSAOApplyShader extends AbstractShaderRenderer GLMC.disableDepthTest(); // apply the rendered SSAO to the LODs - GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, SSAOShader.INSTANCE.frameBuffer); - GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, OpenGlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); + GLMC.glBindFramebuffer(GL32.GL_READ_FRAMEBUFFER, GlDhSSAOShader.INSTANCE.frameBuffer); + GLMC.glBindFramebuffer(GL32.GL_DRAW_FRAMEBUFFER, GlDhMetaRenderer.INSTANCE.getActiveFramebufferId()); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAORenderer.java similarity index 78% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAORenderer.java index d53f94ede..a6730453e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/DhSSAORenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAORenderer.java @@ -17,10 +17,9 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.ssao; -import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLState; +import com.seibel.distanthorizons.common.render.openGl.glObject.GLState; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.render.RenderParams; @@ -32,14 +31,14 @@ import org.lwjgl.opengl.GL43C; import java.nio.ByteBuffer; /** - * Handles adding SSAO via {@link SSAOShader} and {@link SSAOApplyShader}.

+ * Handles adding SSAO via {@link GlDhSSAOShader} and {@link GlDhSSAOApplyShader}.

* - * {@link SSAOShader} - draws the SSAO to a texture.
- * {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
+ * {@link GlDhSSAOShader} - draws the SSAO to a texture.
+ * {@link GlDhSSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
*/ -public class DhSSAORenderer implements IDhSsaoRenderer +public class GlDhSSAORenderer implements IDhSsaoRenderer { - public static DhSSAORenderer INSTANCE = new DhSSAORenderer(); + public static GlDhSSAORenderer INSTANCE = new GlDhSSAORenderer(); private static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -59,15 +58,15 @@ public class DhSSAORenderer implements IDhSsaoRenderer // constructor // //=============// - private DhSSAORenderer() { } + private GlDhSSAORenderer() { } public void init() { if (this.init) return; this.init = true; - SSAOShader.INSTANCE.init(); - SSAOApplyShader.INSTANCE.init(); + GlDhSSAOShader.INSTANCE.init(); + GlDhSSAOApplyShader.INSTANCE.init(); } private void createFramebuffer(int width, int height) @@ -126,12 +125,12 @@ public class DhSSAORenderer implements IDhSsaoRenderer this.createFramebuffer(width, height); } - SSAOShader.INSTANCE.frameBuffer = this.ssaoFramebuffer; - SSAOShader.INSTANCE.setProjectionMatrix(renderParams.dhProjectionMatrix); - SSAOShader.INSTANCE.render(renderParams); + GlDhSSAOShader.INSTANCE.frameBuffer = this.ssaoFramebuffer; + GlDhSSAOShader.INSTANCE.setProjectionMatrix(renderParams.dhProjectionMatrix); + GlDhSSAOShader.INSTANCE.render(renderParams); - SSAOApplyShader.INSTANCE.ssaoTexture = this.ssaoTexture; - SSAOApplyShader.INSTANCE.render(renderParams); + GlDhSSAOApplyShader.INSTANCE.ssaoTexture = this.ssaoTexture; + GlDhSSAOApplyShader.INSTANCE.render(renderParams); } } @@ -146,8 +145,8 @@ public class DhSSAORenderer implements IDhSsaoRenderer public void free() { - SSAOShader.INSTANCE.free(); - SSAOApplyShader.INSTANCE.free(); + GlDhSSAOShader.INSTANCE.free(); + GlDhSSAOApplyShader.INSTANCE.free(); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java similarity index 80% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java index 68111f7b2..a70727753 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/postProcessing/ssao/SSAOShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java @@ -17,15 +17,14 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ssao; +package com.seibel.distanthorizons.common.render.openGl.postProcessing.ssao; import com.seibel.distanthorizons.api.objects.math.DhApiMat4f; -import com.seibel.distanthorizons.common.render.nativeGl.DhTerrainShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhMetaRenderer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.ScreenQuad; +import com.seibel.distanthorizons.common.render.openGl.GlDhMetaRenderer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.GlScreenQuad; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; -import com.seibel.distanthorizons.common.render.nativeGl.util.AbstractShaderRenderer; +import com.seibel.distanthorizons.common.render.openGl.util.GlAbstractShaderRenderer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.util.math.Mat4f; import org.lwjgl.opengl.GL32; @@ -34,12 +33,12 @@ import org.lwjgl.opengl.GL32; * Draws the SSAO to a texture.

* * See Also:
- * {@link DhSSAORenderer} - Parent to this shader.
- * {@link SSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
+ * {@link GlDhSSAORenderer} - Parent to this shader.
+ * {@link GlDhSSAOApplyShader} - draws the SSAO texture to DH's FrameBuffer.
*/ -public class SSAOShader extends AbstractShaderRenderer +public class GlDhSSAOShader extends GlAbstractShaderRenderer { - public static SSAOShader INSTANCE = new SSAOShader(); + public static GlDhSSAOShader INSTANCE = new GlDhSSAOShader(); private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -70,7 +69,7 @@ public class SSAOShader extends AbstractShaderRenderer @Override public void onInit() { - this.shader = new ShaderProgram( + this.shader = new GlShaderProgram( "shaders/quadApply.vert", "shaders/ssao/ao.frag", "vPosition" @@ -135,9 +134,9 @@ public class SSAOShader extends AbstractShaderRenderer GLMC.disableBlend(); GLMC.glActiveTexture(GL32.GL_TEXTURE0); - GLMC.glBindTexture(OpenGlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); + GLMC.glBindTexture(GlDhMetaRenderer.INSTANCE.getActiveDepthTextureId()); - ScreenQuad.INSTANCE.render(); + GlScreenQuad.INSTANCE.render(); } diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java similarity index 79% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java index dc7334285..a0d4eff83 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/test/GlTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java @@ -17,18 +17,18 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.test; +package com.seibel.distanthorizons.common.render.openGl.test; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; -import com.seibel.distanthorizons.common.render.nativeGl.postProcessing.apply.DhApplyShader; +import com.seibel.distanthorizons.common.render.openGl.postProcessing.apply.GlDhApplyShader; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.logging.DhLogger; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.buffer.GLVertexBuffer; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.AbstractVertexAttribute; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.vertexAttribute.VertexPointer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; +import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; @@ -63,9 +63,9 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer - ShaderProgram basicShader; + GlShaderProgram basicShader; GLVertexBuffer vbo; - AbstractVertexAttribute va; + GlAbstractVertexAttribute va; boolean init = false; @@ -86,14 +86,14 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer LOGGER.info("init"); this.init = true; - this.va = AbstractVertexAttribute.create(); + this.va = GlAbstractVertexAttribute.create(); this.va.bind(); // Pos - this.va.setVertexAttribute(0, 0, VertexPointer.addVec2Pointer(false)); + this.va.setVertexAttribute(0, 0, GlVertexPointer.addVec2Pointer(false)); // Color - this.va.setVertexAttribute(0, 1, VertexPointer.addVec4Pointer(false)); + this.va.setVertexAttribute(0, 1, GlVertexPointer.addVec4Pointer(false)); this.va.completeAndCheck(Float.BYTES * 6); - this.basicShader = new ShaderProgram( + this.basicShader = new GlShaderProgram( "shaders/test/vert.vert", "shaders/test/frag.frag", new String[]{"vPosition", "color"}); @@ -136,7 +136,7 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer GL32.glDrawArrays(GL32.GL_TRIANGLES, 0, 3); - DhApplyShader.INSTANCE.render(renderParams); + GlDhApplyShader.INSTANCE.render(renderParams); } //endregion diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/GlAbstractShaderRenderer.java similarity index 89% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/GlAbstractShaderRenderer.java index 9a48970d9..ac8f8c900 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/AbstractShaderRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/GlAbstractShaderRenderer.java @@ -17,20 +17,20 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.util; +package com.seibel.distanthorizons.common.render.openGl.util; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.shader.ShaderProgram; +import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; import com.seibel.distanthorizons.core.dependencyInjection.SingletonInjector; import com.seibel.distanthorizons.core.render.RenderParams; import com.seibel.distanthorizons.core.wrapperInterfaces.minecraft.IMinecraftRenderWrapper; import org.lwjgl.opengl.GL32; -public abstract class AbstractShaderRenderer +public abstract class GlAbstractShaderRenderer { protected static final IMinecraftRenderWrapper MC_RENDER = SingletonInjector.INSTANCE.get(IMinecraftRenderWrapper.class); - protected ShaderProgram shader; + protected GlShaderProgram shader; protected boolean init = false; @@ -39,7 +39,7 @@ public abstract class AbstractShaderRenderer //=======// //region - protected AbstractShaderRenderer() {} + protected GlAbstractShaderRenderer() {} public void init() { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormat.java similarity index 79% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormat.java index 509c9e872..049b9d5d4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormat.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormat.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; +package com.seibel.distanthorizons.common.render.openGl.util.vertexFormat; import java.util.stream.Collectors; @@ -37,22 +37,22 @@ import it.unimi.dsi.fastutil.ints.IntList; * @author James Seibel * @version 12-9-2021 */ -public class LodVertexFormat +public class GlLodVertexFormat { /** the format of data stored in the GPU buffers */ - public static final LodVertexFormat DH_VERTEX_FORMAT = VertexFormats.POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX; + public static final GlLodVertexFormat DH_VERTEX_FORMAT = GlVertexFormats.POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX; - private final ImmutableList elements; + private final ImmutableList elements; private final IntList offsets = new IntArrayList(); private final int byteSize; - public LodVertexFormat(ImmutableList elementList) + public GlLodVertexFormat(ImmutableList elementList) { this.elements = elementList; int i = 0; - for (LodVertexFormatElement LodVertexFormatElement : elementList) + for (GlLodVertexFormatElement LodVertexFormatElement : elementList) { this.offsets.add(i); i += LodVertexFormatElement.getByteSize(); @@ -66,7 +66,7 @@ public class LodVertexFormat return this.byteSize; } - public ImmutableList getElements() + public ImmutableList getElements() { return this.elements; } @@ -93,7 +93,7 @@ public class LodVertexFormat } else if (obj != null && this.getClass() == obj.getClass()) { - LodVertexFormat vertexFormat = (LodVertexFormat) obj; + GlLodVertexFormat vertexFormat = (GlLodVertexFormat) obj; return this.byteSize == vertexFormat.byteSize && this.elements.equals(vertexFormat.elements); } else diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormatElement.java similarity index 87% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormatElement.java index cdc7dc41a..cfc692d53 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/LodVertexFormatElement.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlLodVertexFormatElement.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; +package com.seibel.distanthorizons.common.render.openGl.util.vertexFormat; import org.lwjgl.opengl.GL32; @@ -32,16 +32,16 @@ import org.lwjgl.opengl.GL32; * @author James Seibel * @version 11-13-2021 */ -public class LodVertexFormatElement +public class GlLodVertexFormatElement { - private final LodVertexFormatElement.DataType dataType; + private final GlLodVertexFormatElement.DataType dataType; /** James isn't sure what index is for */ private final int index; private final int count; private final int byteSize; private final boolean isPadding; - public LodVertexFormatElement(int newIndex, LodVertexFormatElement.DataType newType, int newCount, boolean isPadding) + public GlLodVertexFormatElement(int newIndex, GlLodVertexFormatElement.DataType newType, int newCount, boolean isPadding) { this.dataType = newType; this.index = newIndex; @@ -55,7 +55,7 @@ public class LodVertexFormatElement return isPadding; } - public final LodVertexFormatElement.DataType getType() + public final GlLodVertexFormatElement.DataType getType() { return this.dataType; } @@ -141,7 +141,7 @@ public class LodVertexFormatElement } else if (obj != null && this.getClass() == obj.getClass()) { - LodVertexFormatElement LodVertexFormatElement = (LodVertexFormatElement) obj; + GlLodVertexFormatElement LodVertexFormatElement = (GlLodVertexFormatElement) obj; if (this.count != LodVertexFormatElement.count) { return false; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlVertexFormats.java similarity index 50% rename from common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java rename to common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlVertexFormats.java index dc4e04e64..24bb3dbab 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/nativeGl/util/vertexFormat/VertexFormats.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/util/vertexFormat/GlVertexFormats.java @@ -17,7 +17,7 @@ * along with this program. If not, see . */ -package com.seibel.distanthorizons.common.render.nativeGl.util.vertexFormat; +package com.seibel.distanthorizons.common.render.openGl.util.vertexFormat; import com.google.common.collect.ImmutableList; @@ -25,18 +25,18 @@ import com.google.common.collect.ImmutableList; * A (almost) exact copy of MC's * DefaultVertexFormats class. */ -public class VertexFormats +public class GlVertexFormats { - public static final LodVertexFormatElement ELEMENT_POSITION = new LodVertexFormatElement(3, LodVertexFormatElement.DataType.USHORT, 3, false); - public static final LodVertexFormatElement ELEMENT_COLOR = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.UBYTE, 4, false); - public static final LodVertexFormatElement ELEMENT_BYTE_PADDING = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, true); + public static final GlLodVertexFormatElement ELEMENT_POSITION = new GlLodVertexFormatElement(3, GlLodVertexFormatElement.DataType.USHORT, 3, false); + public static final GlLodVertexFormatElement ELEMENT_COLOR = new GlLodVertexFormatElement(0, GlLodVertexFormatElement.DataType.UBYTE, 4, false); + public static final GlLodVertexFormatElement ELEMENT_BYTE_PADDING = new GlLodVertexFormatElement(0, GlLodVertexFormatElement.DataType.BYTE, 1, true); - public static final LodVertexFormatElement ELEMENT_LIGHT = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.UBYTE, 1, false); - public static final LodVertexFormatElement ELEMENT_IRIS_MATERIAL_INDEX = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, false); - public static final LodVertexFormatElement ELEMENT_IRIS_NORMAL_INDEX = new LodVertexFormatElement(0, LodVertexFormatElement.DataType.BYTE, 1, false); + public static final GlLodVertexFormatElement ELEMENT_LIGHT = new GlLodVertexFormatElement(0, GlLodVertexFormatElement.DataType.UBYTE, 1, false); + public static final GlLodVertexFormatElement ELEMENT_IRIS_MATERIAL_INDEX = new GlLodVertexFormatElement(0, GlLodVertexFormatElement.DataType.BYTE, 1, false); + public static final GlLodVertexFormatElement ELEMENT_IRIS_NORMAL_INDEX = new GlLodVertexFormatElement(0, GlLodVertexFormatElement.DataType.BYTE, 1, false); - public static final LodVertexFormat POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX = new LodVertexFormat(ImmutableList.builder() + public static final GlLodVertexFormat POSITION_COLOR_BLOCK_LIGHT_SKY_LIGHT_MATERIAL_ID_NORMAL_INDEX = new GlLodVertexFormat(ImmutableList.builder() .add(ELEMENT_POSITION) .add(ELEMENT_BYTE_PADDING) .add(ELEMENT_LIGHT) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index 15163d609..d743e99fa 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -22,7 +22,7 @@ package com.seibel.distanthorizons.common.wrappers; import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.api.interfaces.render.IDhApiCustomRenderObjectFactory; import com.seibel.distanthorizons.common.render.blaze.BlazeDhRenderApiDefinition; -import com.seibel.distanthorizons.common.render.nativeGl.OpenGlDhRenderApiDefinition; +import com.seibel.distanthorizons.common.render.openGl.GlDhRenderApiDefinition; import com.seibel.distanthorizons.core.config.Config; import com.seibel.distanthorizons.core.render.renderer.GenericRenderObjectFactory; import com.seibel.distanthorizons.common.wrappers.gui.ClassicConfigGUI; @@ -97,7 +97,7 @@ public class DependencySetup AbstractDhRenderApiDefinition renderDefinition; if (renderingApiEnum == EDhApiRenderApi.OPEN_GL) { - renderDefinition = new OpenGlDhRenderApiDefinition(); + renderDefinition = new GlDhRenderApiDefinition(); } else if (renderingApiEnum == EDhApiRenderApi.BLAZE_3D) { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java index de8442cd0..eeb9996d2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftClientWrapper.java @@ -24,7 +24,6 @@ import java.io.File; import com.mojang.blaze3d.platform.Window; import com.seibel.distanthorizons.common.wrappers.world.ClientLevelWrapper; import com.seibel.distanthorizons.core.file.structure.ClientOnlySaveStructure; -import com.seibel.distanthorizons.common.render.nativeGl.glObject.GLProxy; import com.seibel.distanthorizons.core.render.RenderThreadTaskHandler; import com.seibel.distanthorizons.core.wrapperInterfaces.world.IClientLevelWrapper; import com.seibel.distanthorizons.coreapi.ModInfo; From 15a044d0598ae1d49853406b3e1303c062346a8c Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:50:41 -0500 Subject: [PATCH 61/72] Fix fog with Blaze3D --- .../common/render/blaze/postProcessing/BlazeDhFogRenderer.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index 8a2b3c81c..f8f86c2b7 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -337,7 +337,7 @@ public class BlazeDhFogRenderer implements IDhFogRenderer /*depthTexture*/ null, /*optionalDepthValueAsDouble*/ OptionalDouble.empty())) { - renderPass.bindTexture("uDhDepthTexture", this.fogColorTextureWrapper.textureView, this.fogColorTextureWrapper.textureSampler); + renderPass.bindTexture("uDhDepthTexture", BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureView, BlazeDhMetaRenderer.INSTANCE.dhDepthTextureWrapper.textureSampler); renderPass.setUniform("fragUniformBlock", this.fragUniformBuffer); From 33d37b3937be8c2d3ee2b37ef0c3aae44854446c Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 17:56:11 -0500 Subject: [PATCH 62/72] move GL shaders into the correct folder --- .../common/render/openGl/GlDhDebugWireframeRenderer.java | 4 ++-- .../common/render/openGl/GlDhTerrainShaderProgram.java | 4 ++-- .../openGl/generic/GlGenericObjectShaderProgram.java | 8 ++++---- .../openGl/postProcessing/apply/GlDhApplyShader.java | 4 ++-- .../postProcessing/fade/GlDhFarFadeApplyShader.java | 4 ++-- .../openGl/postProcessing/fade/GlDhFarFadeShader.java | 4 ++-- .../openGl/postProcessing/fade/GlDhVanillaFadeShader.java | 4 ++-- .../openGl/postProcessing/fog/GlDhFogApplyShader.java | 4 ++-- .../render/openGl/postProcessing/fog/GlDhFogShader.java | 4 ++-- .../openGl/postProcessing/ssao/GlDhSSAOApplyShader.java | 4 ++-- .../render/openGl/postProcessing/ssao/GlDhSSAOShader.java | 4 ++-- .../common/render/openGl/test/GlTestTriangleRenderer.java | 4 ++-- coreSubProjects | 2 +- 13 files changed, 27 insertions(+), 27 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java index 13d225995..93ab5580a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java @@ -114,8 +114,8 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer this.va.setVertexAttribute(0, 0, GlVertexPointer.addVec3Pointer(false)); this.va.completeAndCheck(Float.BYTES * 3); this.basicShader = new GlShaderProgram( - "shaders/debug/vert.vert", - "shaders/debug/frag.frag", + "assets/distanthorizons/shaders/debug/gl/vert.vert", + "assets/distanthorizons/shaders/debug/gl/frag.frag", "vPosition" ); this.createBuffer(); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java index 04e7a2f02..2d051735a 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhTerrainShaderProgram.java @@ -109,8 +109,8 @@ public class GlDhTerrainShaderProgram extends GlShaderProgram implements IDhApiS private GlDhTerrainShaderProgram() { super( - "shaders/standard.vert", - "shaders/flat_shaded.frag", + "assets/distanthorizons/shaders/shared/gl/standard.vert", + "assets/distanthorizons/shaders/shared/gl/flat_shaded.frag", new String[]{"vPosition", "color"} ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java index 6340213c2..768c8a7c6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/generic/GlGenericObjectShaderProgram.java @@ -17,10 +17,10 @@ import com.seibel.distanthorizons.core.util.math.Vec3f; public class GlGenericObjectShaderProgram extends GlShaderProgram implements IDhApiGenericObjectShaderProgram { - public static final String VERTEX_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/vert.vert"; - public static final String VERTEX_SHADER_DIRECT_PATH = "shaders/genericObject/direct/vert.vert"; - public static final String FRAGMENT_SHADER_INSTANCED_PATH = "shaders/genericObject/instanced/frag.frag"; - public static final String FRAGMENT_SHADER_DIRECT_PATH = "shaders/genericObject/direct/frag.frag"; + public static final String VERTEX_SHADER_INSTANCED_PATH = "assets/distanthorizons/shaders/generic/gl/instanced/vert.vert"; + public static final String VERTEX_SHADER_DIRECT_PATH = "assets/distanthorizons/shaders/generic/gl/direct/vert.vert"; + public static final String FRAGMENT_SHADER_INSTANCED_PATH = "assets/distanthorizons/shaders/generic/gl/instanced/frag.frag"; + public static final String FRAGMENT_SHADER_DIRECT_PATH = "assets/distanthorizons/shaders/generic/gl/direct/frag.frag"; public final GlAbstractVertexAttribute va; diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java index 7407d0379..4a4f4b04b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/apply/GlDhApplyShader.java @@ -57,8 +57,8 @@ public class GlDhApplyShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/apply.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/shared/gl/apply.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java index 9e7c47ba1..83e30f08e 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeApplyShader.java @@ -59,8 +59,8 @@ public class GlDhFarFadeApplyShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/fade/apply.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/fade/gl/apply.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java index 62f99ea42..ae9a511ff 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhFarFadeShader.java @@ -69,8 +69,8 @@ public class GlDhFarFadeShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/fade/dhFade.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/fade/gl/dhFade.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java index bd0e444c4..15a1ba43c 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fade/GlDhVanillaFadeShader.java @@ -77,8 +77,8 @@ public class GlDhVanillaFadeShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/fade/vanillaFade.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/fade/gl/vanillaFade.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java index 4db8c0b6b..affbce795 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogApplyShader.java @@ -57,8 +57,8 @@ public class GlDhFogApplyShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/fog/apply.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/fog/gl/apply.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java index c176a07bf..05efafdfb 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/fog/GlDhFogShader.java @@ -109,8 +109,8 @@ public class GlDhFogShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/fog/fog.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/fog/gl/fog.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java index 18a97f29a..d12663de2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOApplyShader.java @@ -62,8 +62,8 @@ public class GlDhSSAOApplyShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/ssao/apply.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/ssao/gl/apply.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java index a70727753..77cd454af 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/postProcessing/ssao/GlDhSSAOShader.java @@ -70,8 +70,8 @@ public class GlDhSSAOShader extends GlAbstractShaderRenderer public void onInit() { this.shader = new GlShaderProgram( - "shaders/quadApply.vert", - "shaders/ssao/ao.frag", + "assets/distanthorizons/shaders/shared/gl/quadApply.vert", + "assets/distanthorizons/shaders/ssao/gl/ao.frag", "vPosition" ); diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java index a0d4eff83..c2cb3fbc0 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/test/GlTestTriangleRenderer.java @@ -94,8 +94,8 @@ public class GlTestTriangleRenderer implements IDhTestTriangleRenderer this.va.setVertexAttribute(0, 1, GlVertexPointer.addVec4Pointer(false)); this.va.completeAndCheck(Float.BYTES * 6); this.basicShader = new GlShaderProgram( - "shaders/test/vert.vert", - "shaders/test/frag.frag", + "assets/distanthorizons/shaders/test/gl/vert.vert", + "assets/distanthorizons/shaders/test/gl/frag.frag", new String[]{"vPosition", "color"}); this.createBuffer(); diff --git a/coreSubProjects b/coreSubProjects index e426fc238..1bbe41c06 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit e426fc238022d8f4c584e6ff6d505a62564ebcab +Subproject commit 1bbe41c0685546fa91c95ddd265fac78949ff43b From b552bf2566f79c52de2916ff3d9108825bd5b2b2 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 18:44:02 -0500 Subject: [PATCH 63/72] Fix block state wrapper for old MC versions --- .../wrappers/block/BlockStateWrapper.java | 23 ++++++++++--------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/BlockStateWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/BlockStateWrapper.java index 8f08e87c8..1deff2935 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/BlockStateWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/block/BlockStateWrapper.java @@ -93,15 +93,6 @@ public class BlockStateWrapper implements IBlockStateWrapper public static final String DIRT_RESOURCE_LOCATION_STRING = "minecraft:dirt"; public static final String WATER_RESOURCE_LOCATION_STRING = "minecraft:water"; - /** Used to handle older MC versions that don't have an simple way of getting the block's tags */ - public static final List OLD_BEACON_BASE_BLOCK_NAME_LIST = Arrays.asList( - "iron_block", - "gold_block", - "diamond_block", - "emerald_block", - "netherite_block" - ); - public static ObjectOpenHashSet rendererIgnoredBlocks = null; public static ObjectOpenHashSet rendererIgnoredCaveBlocks = null; @@ -194,11 +185,21 @@ public class BlockStateWrapper implements IBlockStateWrapper // beacon base blocks #if MC_VER <= MC_1_18_2 + + // Used to handle older MC versions that don't have an simple way of getting the block's tags + List oldBeaconBaseBlockNameList = Arrays.asList( + "iron_block", + "gold_block", + "diamond_block", + "emerald_block", + "netherite_block" + ); + // Older MC versions are harder to get block tags, so just use a static list to determine beacon blocks boolean isBeaconBaseBlock = false; - for (int i = 0; i < OLD_BEACON_BASE_BLOCK_NAME_LIST.size(); i++) + for (int i = 0; i < oldBeaconBaseBlockNameList.size(); i++) { - String baseBlockName = OLD_BEACON_BASE_BLOCK_NAME_LIST.get(i); + String baseBlockName = oldBeaconBaseBlockNameList.get(i); if (lowercaseSerial.contains(baseBlockName)) { isBeaconBaseBlock = true; From 045733deb5d277bb9aeb6e295ccf2a47aa94b9df Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 18:44:19 -0500 Subject: [PATCH 64/72] add renderDebugLabels to neoforge args --- fabric/build.gradle | 1 + neoforge/build.gradle | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/fabric/build.gradle b/fabric/build.gradle index 81076a957..dbe0e6311 100644 --- a/fabric/build.gradle +++ b/fabric/build.gradle @@ -23,6 +23,7 @@ loom { "-XX:+UseZGC", "-XX:+ZGenerational" ) + // "--renderDebugLabels" is a Mojang command to show render names in RenderDoc programArgs("--username", "Dev", "--renderDebugLabels") } server { diff --git a/neoforge/build.gradle b/neoforge/build.gradle index 20c8f3f27..b623e98cc 100644 --- a/neoforge/build.gradle +++ b/neoforge/build.gradle @@ -32,7 +32,8 @@ loom { ideConfigGenerated(false) // When true a run configuration file will be generated for IDE's. By default only set to true for the root project. runDir("../run/client") vmArgs("-Dio.netty.leakDetection.level=advanced") // https://netty.io/wiki/reference-counted-objects.html#leak-detection-levels - programArgs("--username", "Dev") + // "--renderDebugLabels" is a Mojang command to show render names in RenderDoc + programArgs("--username", "Dev", "--renderDebugLabels") } server { server() From d73867efd620b3113e26b3f00056b0d22599d05c Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 18:44:30 -0500 Subject: [PATCH 65/72] fix old forge compiling --- .../distanthorizons/fabric/mixins/client/MixinClientLevel.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinClientLevel.java b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinClientLevel.java index 405348409..883cd7115 100644 --- a/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinClientLevel.java +++ b/fabric/src/main/java/com/seibel/distanthorizons/fabric/mixins/client/MixinClientLevel.java @@ -51,7 +51,7 @@ public class MixinClientLevel if (chunk != null && !chunk.isClientLightReady()) { - SharedApi.INSTANCE.chunkLoadEvent( + SharedApi.INSTANCE.applyChunkUpdate( new ChunkWrapper(chunk, ClientLevelWrapper.getWrapper(clientLevel)), ClientLevelWrapper.getWrapper(clientLevel)); } From 3d1af8f944aafc02cfb6792a28905afcac2d0980 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 18:46:49 -0500 Subject: [PATCH 66/72] Disable blaze api for old MC versions --- .../render/blaze/BlazeDebugWireframeRenderer.java | 6 ++++++ .../render/blaze/BlazeDhGenericObjectRenderer.java | 6 ++++++ .../common/render/blaze/BlazeDhMetaRenderer.java | 6 ++++++ .../render/blaze/BlazeDhRenderApiDefinition.java | 6 ++++++ .../common/render/blaze/BlazeDhTerrainRenderer.java | 5 +++++ .../render/blaze/apply/BlazeDhApplyRenderer.java | 6 ++++++ .../render/blaze/apply/BlazeDhCopyRenderer.java | 6 ++++++ .../objects/BlazeGenericObjectVertexContainer.java | 6 ++++++ .../postProcessing/BlazeDhFarFadeRenderer.java | 6 ++++++ .../blaze/postProcessing/BlazeDhFogRenderer.java | 6 ++++++ .../blaze/postProcessing/BlazeDhSsaoRenderer.java | 6 ++++++ .../postProcessing/BlazeVanillaFadeRenderer.java | 6 ++++++ .../blaze/test/BlazeDhTestTriangleRenderer.java | 6 ++++++ .../render/blaze/util/BlazeDhVertexFormatUtil.java | 6 ++++++ .../render/blaze/util/BlazePostProcessUtil.java | 6 ++++++ .../common/render/blaze/util/BlazeUniformUtil.java | 6 ++++++ .../wrappers/buffer/BlazeVertexBufferWrapper.java | 6 ++++++ .../wrappers/texture/BlazeTextureViewWrapper.java | 6 ++++++ .../blaze/wrappers/texture/BlazeTextureWrapper.java | 6 ++++++ .../uniform/BlazeLodUniformBufferWrapper.java | 6 ++++++ .../wrappers/uniform/BlazeUniformBufferWrapper.java | 6 ++++++ .../common/wrappers/DependencySetup.java | 4 ++++ .../wrappers/minecraft/MinecraftRenderWrapper.java | 8 +++++--- .../common/wrappers/misc/LightMapWrapper.java | 13 ++++++++++++- coreSubProjects | 2 +- 25 files changed, 147 insertions(+), 5 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index a1db1eb56..aa6fe7383 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze; +#if MC_VER <= MC_1_21_10 +public class BlazeDebugWireframeRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -322,3 +327,4 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index 05859dfec..5185353f6 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze; +#if MC_VER <= MC_1_21_10 +public class BlazeDhGenericObjectRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -622,3 +627,4 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java index 71bf83451..e71e91dab 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhMetaRenderer.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze; +#if MC_VER <= MC_1_21_10 +public class BlazeDhMetaRenderer {} + +#else + import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.common.render.blaze.apply.BlazeDhApplyRenderer; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureWrapper; @@ -86,3 +91,4 @@ public class BlazeDhMetaRenderer implements IDhMetaRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java index f91eb3c32..4c40669a4 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhRenderApiDefinition.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze; +#if MC_VER <= MC_1_21_10 +public class BlazeDhRenderApiDefinition {} + +#else + import com.seibel.distanthorizons.common.render.blaze.objects.BlazeGenericObjectVertexContainer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFarFadeRenderer; import com.seibel.distanthorizons.common.render.blaze.postProcessing.BlazeDhFogRenderer; @@ -63,3 +68,4 @@ public class BlazeDhRenderApiDefinition extends AbstractDhRenderApiDefinition } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java index 11b3845dd..27513a919 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhTerrainRenderer.java @@ -1,5 +1,9 @@ package com.seibel.distanthorizons.common.render.blaze; +#if MC_VER <= MC_1_21_10 +public class BlazeDhTerrainRenderer {} + +#else import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; @@ -387,3 +391,4 @@ public class BlazeDhTerrainRenderer implements IDhTerrainRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java index 636716246..83accc661 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhApplyRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.apply; +#if MC_VER <= MC_1_21_10 +public class BlazeDhApplyRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.pipeline.BlendFunction; import com.mojang.blaze3d.pipeline.RenderPipeline; @@ -260,3 +265,4 @@ public class BlazeDhApplyRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java index 429e8ac21..7286a0758 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/apply/BlazeDhCopyRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.apply; +#if MC_VER <= MC_1_21_10 +public class BlazeDhCopyRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.pipeline.RenderPipeline; import com.mojang.blaze3d.platform.DepthTestFunction; @@ -157,3 +162,4 @@ public class BlazeDhCopyRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java index b6fe50565..34b16009f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/objects/BlazeGenericObjectVertexContainer.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.objects; +#if MC_VER <= MC_1_21_10 +public class BlazeGenericObjectVertexContainer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; @@ -277,3 +282,4 @@ public class BlazeGenericObjectVertexContainer implements IDhGenericObjectVertex } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java index 9f01b56c4..8d1d0a451 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFarFadeRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.postProcessing; +#if MC_VER <= MC_1_21_10 +public class BlazeDhFarFadeRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -227,3 +232,4 @@ public class BlazeDhFarFadeRenderer implements IDhFarFadeRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java index f8f86c2b7..4d20e9c65 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhFogRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.postProcessing; +#if MC_VER <= MC_1_21_10 +public class BlazeDhFogRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -355,3 +360,4 @@ public class BlazeDhFogRenderer implements IDhFogRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java index f9de81aa8..87f0e91b1 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeDhSsaoRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.postProcessing; +#if MC_VER <= MC_1_21_10 +public class BlazeDhSsaoRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -275,3 +280,4 @@ public class BlazeDhSsaoRenderer implements IDhSsaoRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java index 788fd1538..f1d7166c2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/postProcessing/BlazeVanillaFadeRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.postProcessing; +#if MC_VER <= MC_1_21_10 +public class BlazeVanillaFadeRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.buffers.Std140Builder; @@ -254,3 +259,4 @@ public class BlazeVanillaFadeRenderer implements IDhVanillaFadeRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java index 563b82853..aaa295de2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/test/BlazeDhTestTriangleRenderer.java @@ -19,6 +19,11 @@ package com.seibel.distanthorizons.common.render.blaze.test; +#if MC_VER <= MC_1_21_10 +public class BlazeDhTestTriangleRenderer {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.pipeline.RenderPipeline; @@ -184,3 +189,4 @@ public class BlazeDhTestTriangleRenderer implements IDhTestTriangleRenderer } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java index 810d77d4d..d4cea9b20 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeDhVertexFormatUtil.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.util; +#if MC_VER <= MC_1_21_10 +public class BlazeDhVertexFormatUtil {} + +#else + import com.mojang.blaze3d.vertex.VertexFormatElement; import com.seibel.distanthorizons.api.enums.config.EDhApiRenderApi; import com.seibel.distanthorizons.core.config.Config; @@ -97,3 +102,4 @@ public class BlazeDhVertexFormatUtil } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java index bca3e31f5..c1a29951f 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazePostProcessUtil.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.util; +#if MC_VER <= MC_1_21_10 +public class BlazePostProcessUtil {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; @@ -73,3 +78,4 @@ public class BlazePostProcessUtil } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java index e9262a797..6b40aaa11 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/util/BlazeUniformUtil.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.util; +#if MC_VER <= MC_1_21_10 +public class BlazeUniformUtil {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; @@ -30,3 +35,4 @@ public class BlazeUniformUtil } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java index cfe982fcd..ea707adfc 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/buffer/BlazeVertexBufferWrapper.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.buffer; +#if MC_VER <= MC_1_21_10 +public class BlazeVertexBufferWrapper {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; @@ -82,3 +87,4 @@ public class BlazeVertexBufferWrapper implements IVertexBufferWrapper } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java index 991982410..5f5a33d2b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureViewWrapper.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.texture; +#if MC_VER <= MC_1_21_10 +public class BlazeTextureViewWrapper {} + +#else + import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; import com.mojang.blaze3d.systems.RenderSystem; @@ -64,3 +69,4 @@ public class BlazeTextureViewWrapper } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java index 60557565c..fe1a3a8f2 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/texture/BlazeTextureWrapper.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.texture; +#if MC_VER <= MC_1_21_10 +public class BlazeTextureWrapper {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.systems.CommandEncoder; import com.mojang.blaze3d.systems.GpuDevice; @@ -159,3 +164,4 @@ public class BlazeTextureWrapper } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java index 0ac76e60e..ba39f5018 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeLodUniformBufferWrapper.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.uniform; +#if MC_VER <= MC_1_21_10 +public class BlazeLodUniformBufferWrapper {} + +#else + import com.mojang.blaze3d.buffers.Std140Builder; import com.mojang.blaze3d.buffers.Std140SizeCalculator; import com.seibel.distanthorizons.core.dataObjects.render.bufferBuilding.LodBufferContainer; @@ -68,3 +73,4 @@ public class BlazeLodUniformBufferWrapper extends BlazeUniformBufferWrapper impl //endregion } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java index 55b25e612..a487b0bde 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/wrappers/uniform/BlazeUniformBufferWrapper.java @@ -1,5 +1,10 @@ package com.seibel.distanthorizons.common.render.blaze.wrappers.uniform; +#if MC_VER <= MC_1_21_10 +public class BlazeUniformBufferWrapper {} + +#else + import com.mojang.blaze3d.buffers.GpuBuffer; import com.mojang.blaze3d.buffers.GpuBufferSlice; import com.mojang.blaze3d.systems.CommandEncoder; @@ -122,3 +127,4 @@ public class BlazeUniformBufferWrapper implements IUniformBufferWrapper } +#endif \ No newline at end of file diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java index d743e99fa..caa9b8a64 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/DependencySetup.java @@ -101,7 +101,11 @@ public class DependencySetup } else if (renderingApiEnum == EDhApiRenderApi.BLAZE_3D) { + #if MC_VER <= MC_1_21_10 + throw new IllegalStateException("["+renderingApiEnum+"] is not supported on this version of Minecraft."); + #else renderDefinition = new BlazeDhRenderApiDefinition(); + #endif } else { diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java index d2d685c1b..fede80a71 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/minecraft/MinecraftRenderWrapper.java @@ -25,13 +25,10 @@ import java.util.concurrent.ConcurrentHashMap; import com.mojang.blaze3d.pipeline.RenderTarget; import com.mojang.blaze3d.platform.NativeImage; -import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.api.enums.config.EDhApiLodShading; import com.seibel.distanthorizons.common.wrappers.McObjectConverter; import com.seibel.distanthorizons.common.wrappers.misc.LightMapWrapper; -import com.seibel.distanthorizons.core.api.internal.ClientApi; import com.seibel.distanthorizons.core.config.Config; -import com.seibel.distanthorizons.core.dependencyInjection.ModAccessorInjector; import com.seibel.distanthorizons.core.enums.EDhDirection; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -88,6 +85,7 @@ import com.mojang.blaze3d.opengl.GlTexture; #if MC_VER <= MC_1_21_10 #else import net.minecraft.world.attribute.EnvironmentAttributes; +import com.mojang.blaze3d.textures.GpuTexture; #endif /** @@ -489,6 +487,9 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper()); wrapper.setLightmapId(tetxureId); } + + #if MC_VER <= MC_1_21_10 + #else public void setLightmapGpuTexture(GpuTexture gpuTexture, IClientLevelWrapper level) { // Using ClientLevelWrapper as the key would be better, but we don't have a consistent way to create the same @@ -499,6 +500,7 @@ public class MinecraftRenderWrapper implements IMinecraftRenderWrapper LightMapWrapper wrapper = this.lightmapByDimensionType.computeIfAbsent(dimensionType, (dimType) -> new LightMapWrapper()); wrapper.setLightmapGpuTexture(gpuTexture); } + #endif @Override public float getShade(EDhDirection lodDirection) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java index 5bee728d6..775a5ef77 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/wrappers/misc/LightMapWrapper.java @@ -20,7 +20,6 @@ package com.seibel.distanthorizons.common.wrappers.misc; import com.mojang.blaze3d.platform.NativeImage; -import com.mojang.blaze3d.textures.GpuTexture; import com.seibel.distanthorizons.common.render.blaze.wrappers.texture.BlazeTextureViewWrapper; import com.seibel.distanthorizons.common.wrappers.minecraft.MinecraftGLWrapper; import com.seibel.distanthorizons.core.logging.DhLoggerBuilder; @@ -33,6 +32,11 @@ import java.nio.ByteBuffer; #else #endif +#if MC_VER <= MC_1_21_10 +#else +import com.mojang.blaze3d.textures.GpuTexture; +#endif + public class LightMapWrapper implements ILightMapWrapper { private static final MinecraftGLWrapper GLMC = MinecraftGLWrapper.INSTANCE; @@ -46,7 +50,11 @@ public class LightMapWrapper implements ILightMapWrapper private int textureId = 0; + #if MC_VER <= MC_1_21_10 + #else private GpuTexture gpuTexture = null; + #endif + private final BlazeTextureViewWrapper lightmapTextureWrapper = new BlazeTextureViewWrapper(); @@ -109,11 +117,14 @@ public class LightMapWrapper implements ILightMapWrapper this.textureId = minecraftLightmapTextureId; } + #if MC_VER <= MC_1_21_10 + #else public void setLightmapGpuTexture(GpuTexture gpuTexture) { this.gpuTexture = gpuTexture; this.lightmapTextureWrapper.tryWrap(this.gpuTexture); } + #endif //endregion diff --git a/coreSubProjects b/coreSubProjects index 1bbe41c06..d75b65e6e 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 1bbe41c0685546fa91c95ddd265fac78949ff43b +Subproject commit d75b65e6e72716f43c2879b67c4732536fbd411c From f13095875f14dfa7427c9e8a0b2ccf46c095bee7 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:06:09 -0500 Subject: [PATCH 67/72] fix debug wireframes not rendering --- .../openGl/GlDhDebugWireframeRenderer.java | 26 +++++++++++++------ coreSubProjects | 2 +- 2 files changed, 19 insertions(+), 9 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java index 93ab5580a..6399a7d54 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/openGl/GlDhDebugWireframeRenderer.java @@ -21,6 +21,7 @@ package com.seibel.distanthorizons.common.render.openGl; import com.seibel.distanthorizons.api.enums.config.EDhApiGpuUploadMethod; import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLElementBuffer; +import com.seibel.distanthorizons.common.render.openGl.glObject.buffer.GLVertexBuffer; import com.seibel.distanthorizons.common.render.openGl.glObject.shader.GlShaderProgram; import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlAbstractVertexAttribute; import com.seibel.distanthorizons.common.render.openGl.glObject.vertexAttribute.GlVertexPointer; @@ -51,7 +52,8 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer // rendering setup private GlShaderProgram basicShader; - private GLElementBuffer outlineIndexBuffer; + private GLVertexBuffer vertexBuffer; + private GLElementBuffer indexBuffer; private GlAbstractVertexAttribute va; private boolean init = false; @@ -120,7 +122,7 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer ); this.createBuffer(); } - + private void createBuffer() { // box vertices @@ -128,6 +130,9 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer boxVerticesBuffer.order(ByteOrder.nativeOrder()); boxVerticesBuffer.asFloatBuffer().put(BOX_VERTICES); boxVerticesBuffer.rewind(); + this.vertexBuffer = new GLVertexBuffer(false); + this.vertexBuffer.bind(); + this.vertexBuffer.uploadBuffer(boxVerticesBuffer, 8, EDhApiGpuUploadMethod.DATA, BOX_VERTICES.length * Float.BYTES); // outline vertex indexes @@ -135,11 +140,12 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer boxOutlineBuffer.order(ByteOrder.nativeOrder()); boxOutlineBuffer.asIntBuffer().put(BOX_OUTLINE_INDICES); boxOutlineBuffer.rewind(); - this.outlineIndexBuffer = new GLElementBuffer(false); - this.outlineIndexBuffer.uploadBuffer(boxOutlineBuffer, EDhApiGpuUploadMethod.DATA, BOX_OUTLINE_INDICES.length * Integer.BYTES, GL32.GL_STATIC_DRAW); + this.indexBuffer = new GLElementBuffer(false); + this.indexBuffer.uploadBuffer(boxOutlineBuffer, EDhApiGpuUploadMethod.DATA, BOX_OUTLINE_INDICES.length * Integer.BYTES, GL32.GL_STATIC_DRAW); } + //endregion @@ -150,7 +156,7 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer //region @Override - public void renderPass(RenderParams renderParams) + public void render(RenderParams renderParams) { this.init(); @@ -159,14 +165,18 @@ public class GlDhDebugWireframeRenderer extends AbstractDebugWireframeRenderer this.basicShader.bind(); this.va.bind(); + this.va.bindBufferToAllBindingPoints(this.vertexBuffer.getId()); - this.outlineIndexBuffer.bind(); + this.indexBuffer.bind(); - super.renderPass(renderParams); + super.render(renderParams); + + // revert to prevent issues with the following passes + GL32.glPolygonMode(GL32.GL_FRONT_AND_BACK, GL32.GL_FILL); } @Override - public void render(Box box) + public void renderBox(Box box) { Mat4f boxTransform = Mat4f.createTranslateMatrix(box.minPos.x - this.camPosFloatThisFrame.x, box.minPos.y - this.camPosFloatThisFrame.y, box.minPos.z - this.camPosFloatThisFrame.z); boxTransform.multiply(Mat4f.createScaleMatrix(box.maxPos.x - box.minPos.x, box.maxPos.y - box.minPos.y, box.maxPos.z - box.minPos.z)); diff --git a/coreSubProjects b/coreSubProjects index d75b65e6e..31b6d2dd0 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit d75b65e6e72716f43c2879b67c4732536fbd411c +Subproject commit 31b6d2dd05e5b4b4368aa982a01e653ad24ab5c8 From e4c769e95e23d49237fee26829011d8e32b31087 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:07:07 -0500 Subject: [PATCH 68/72] merge blaze renderer changes --- coreSubProjects | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/coreSubProjects b/coreSubProjects index 31b6d2dd0..89e6355d7 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 31b6d2dd05e5b4b4368aa982a01e653ad24ab5c8 +Subproject commit 89e6355d7314f5509957d6c91f77de2f845c1be3 From ce528f3fd547bc1cf40ce3eda5276574135c8958 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:07:50 -0500 Subject: [PATCH 69/72] up DH version 2.4.6 -> 3.0.0 --- coreSubProjects | 2 +- gradle.properties | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/coreSubProjects b/coreSubProjects index 89e6355d7..0eba376e7 160000 --- a/coreSubProjects +++ b/coreSubProjects @@ -1 +1 @@ -Subproject commit 89e6355d7314f5509957d6c91f77de2f845c1be3 +Subproject commit 0eba376e7056389d28943ed39ed114ee1de72e37 diff --git a/gradle.properties b/gradle.properties index 0971562b1..4942ca85b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -5,8 +5,8 @@ org.gradle.caching=true # Mod Info mod_name=DistantHorizons -mod_version=2.4.6-b-dev api_version=5.1.0 +mod_version=3.0.0-b-dev maven_group=com.seibel.distanthorizons mod_readable_name=Distant Horizons mod_description=This mod generates and renders simplified terrain beyond the normal view distance at a low performance cost. Allowing you to see much farther without turning your game into a slideshow. From 4b5a4dda79b681fae6c10f61b384e22aa36977f6 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:08:01 -0500 Subject: [PATCH 70/72] Up API version 5.1.0 -> 6.0.0 --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index 4942ca85b..ba7b2f522 100644 --- a/gradle.properties +++ b/gradle.properties @@ -5,8 +5,8 @@ org.gradle.caching=true # Mod Info mod_name=DistantHorizons -api_version=5.1.0 mod_version=3.0.0-b-dev +api_version=6.0.0 maven_group=com.seibel.distanthorizons mod_readable_name=Distant Horizons mod_description=This mod generates and renders simplified terrain beyond the normal view distance at a low performance cost. Allowing you to see much farther without turning your game into a slideshow. From a1d493f25dffb367797e2f57fd30973af50c0379 Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:18:03 -0500 Subject: [PATCH 71/72] fix refactor rename --- .../common/render/blaze/BlazeDebugWireframeRenderer.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java index aa6fe7383..37d46b48b 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDebugWireframeRenderer.java @@ -225,7 +225,7 @@ public class BlazeDebugWireframeRenderer extends AbstractDebugWireframeRenderer //region @Override - public void render(Box box) + public void renderBox(Box box) { this.init(); From 034aaddca3faadbb3f47546203810668c70be3db Mon Sep 17 00:00:00 2001 From: James Seibel Date: Tue, 10 Mar 2026 19:26:28 -0500 Subject: [PATCH 72/72] Allow translucent generic objects --- .../blaze/BlazeDhGenericObjectRenderer.java | 20 ++++--------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java index 5185353f6..867dad491 100644 --- a/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java +++ b/common/src/main/java/com/seibel/distanthorizons/common/render/blaze/BlazeDhGenericObjectRenderer.java @@ -110,8 +110,7 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer private VertexFormat vertexFormat; - private RenderPipeline opaquePipeline; - private RenderPipeline transparentPipeline; + private RenderPipeline pipeline; private GpuBuffer vertUniformBuffer; @@ -152,6 +151,7 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer pipelineBuilder.withCull(true); pipelineBuilder.withDepthWrite(true); pipelineBuilder.withDepthTestFunction(DepthTestFunction.LESS_DEPTH_TEST); + pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); pipelineBuilder.withColorWrite(true); pipelineBuilder.withPolygonMode(PolygonMode.FILL); pipelineBuilder.withLocation(Identifier.parse("distanthorizons:generic")); @@ -164,20 +164,8 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer pipelineBuilder.withUniform("vertUniformBlock", UniformType.UNIFORM_BUFFER); pipelineBuilder.withVertexFormat(this.vertexFormat, VertexFormat.Mode.TRIANGLES); + this.pipeline = pipelineBuilder.build(); } - - // opaque - { - pipelineBuilder.withoutBlend(); - this.opaquePipeline = pipelineBuilder.build(); - } - - // transparent - { - pipelineBuilder.withBlend(BlendFunction.TRANSLUCENT); - this.transparentPipeline = pipelineBuilder.build(); - } - } private void addGenericDebugObjects() { @@ -568,7 +556,7 @@ public class BlazeDhGenericObjectRenderer implements IDhGenericRenderer renderPass.setUniform("vertUniformBlock", this.vertUniformBuffer); // set pipeline - renderPass.setPipeline(this.opaquePipeline); // TODO + renderPass.setPipeline(this.pipeline); renderPass.setIndexBuffer(container.indexGpuBuffer, VertexFormat.IndexType.INT); renderPass.setVertexBuffer(0, container.vboGpuBuffer);