package net.coderbot.iris.compat.dh; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.rendering.RenderingState; import com.seibel.distanthorizons.api.DhApi; import com.seibel.distanthorizons.api.enums.rendering.EDhApiFogDrawMode; import com.seibel.distanthorizons.api.enums.rendering.EDhApiRenderPass; import com.seibel.distanthorizons.api.interfaces.override.IDhApiOverrideable; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiFramebuffer; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiGenericObjectShaderProgram; import com.seibel.distanthorizons.api.interfaces.override.rendering.IDhApiShadowCullingFrustum; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiAfterDhInitEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeApplyShaderRenderEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeBufferRenderEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeDeferredRenderEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericObjectRenderEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeGenericRenderSetupEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderCleanupEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderPassEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeRenderSetupEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiBeforeTextureClearEvent; import com.seibel.distanthorizons.api.methods.events.abstractEvents.DhApiColorDepthTextureCreatedEvent; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiCancelableEventParam; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiEventParam; import com.seibel.distanthorizons.api.methods.events.sharedParameterObjects.DhApiRenderParam; import com.seibel.distanthorizons.api.objects.math.DhApiVec3f; import com.seibel.distanthorizons.coreapi.DependencyInjection.OverrideInjector; import net.coderbot.iris.Iris; import net.coderbot.iris.pipeline.ShadowRenderer; import net.coderbot.iris.pipeline.WorldRenderingPipeline; import net.coderbot.iris.shadows.ShadowRenderingState; import net.coderbot.iris.uniforms.CapturedRenderingState; import net.irisshaders.iris.api.v0.IrisApi; import org.joml.Matrix4f; import org.joml.Matrix4fc; import org.lwjgl.opengl.GL11; public class LodRendererEvents { // TODO: Query actual world min height for Cubic Chunks compatibility private static final int WORLD_MIN_Y = 0; private static boolean eventHandlersBound = false; private static boolean atTranslucent = false; private static int textureWidth; private static int textureHeight; private static final Matrix4f tempMat4 = new Matrix4f(); private static boolean dhMatricesActive = false; private static final Matrix4f savedModelView = new Matrix4f(); private static final Matrix4f savedProjection = new Matrix4f(); static void pushDhMatrices(Matrix4fc projection, Matrix4fc modelView) { if (!dhMatricesActive) { savedModelView.set(GLStateManager.getModelViewMatrix()); savedProjection.set(GLStateManager.getProjectionMatrix()); dhMatricesActive = true; } GLStateManager.setModelViewMatrix(modelView); GLStateManager.setProjectionMatrix(projection); } static void popDhMatrices() { if (dhMatricesActive) { GLStateManager.setModelViewMatrix(savedModelView); GLStateManager.setProjectionMatrix(savedProjection); dhMatricesActive = false; } } // constructor // public static void setupEventHandlers() { if (!eventHandlersBound) { eventHandlersBound = true; Iris.logger.info("Queuing DH event binding..."); DhApiAfterDhInitEvent beforeCleanupEvent = new DhApiAfterDhInitEvent() { @Override public void afterDistantHorizonsInit(DhApiEventParam event) { Iris.logger.info("DH Ready, binding Iris event handlers..."); Iris.loadShaderpackWhenPossible(); setupSetDeferredBeforeRenderingEvent(); setupReconnectDepthTextureEvent(); setupGenericEvent(); setupCreateDepthTextureEvent(); setupTransparentRendererEventCancling(); setupBeforeBufferClearEvent(); setupBeforeRenderCleanupEvent(); beforeBufferRenderEvent(); setupBeforeRenderFrameBufferBinding(); setupBeforeRenderPassEvent(); setupBeforeApplyShaderEvent(); DHCompatInternal.dhEnabled = DhApi.Delayed.configs.graphics().renderingEnabled().getValue(); Iris.logger.info("DH Iris events bound."); } }; DhApi.events.bind(DhApiAfterDhInitEvent.class, beforeCleanupEvent); } } // setup event handlers // private static void setupSetDeferredBeforeRenderingEvent() { DhApiBeforeRenderEvent beforeRenderEvent = new DhApiBeforeRenderEvent() { // this event is called before DH starts any rendering prep // canceling it will prevent DH from rendering for that frame @Override public void beforeRender(DhApiCancelableEventParam event) { DhApi.Delayed.renderProxy.setDeferTransparentRendering(IrisApi.getInstance().isShaderPackInUse() && getInstance().shouldOverride); DhApi.Delayed.configs.graphics().fog().drawMode().setValue(getInstance().shouldOverride ? EDhApiFogDrawMode.FOG_DISABLED : EDhApiFogDrawMode.FOG_ENABLED); } }; DhApi.events.bind(DhApiBeforeRenderEvent.class, beforeRenderEvent); } private static void setupReconnectDepthTextureEvent() { DhApiBeforeTextureClearEvent beforeRenderEvent = new DhApiBeforeTextureClearEvent() { @Override public void beforeClear(DhApiCancelableEventParam event) { var getResult = DhApi.Delayed.renderProxy.getDhDepthTextureId(); if (getResult.success) { int depthTextureId = getResult.payload; getInstance().reconnectDHTextures(depthTextureId); } } }; DhApi.events.bind(DhApiBeforeTextureClearEvent.class, beforeRenderEvent); } private static void setupGenericEvent() { DhApiBeforeGenericRenderSetupEvent beforeRenderEvent = new DhApiBeforeGenericRenderSetupEvent() { @Override public void beforeSetup(DhApiEventParam dhApiEventParam) { if (getInstance().getGenericFB() != null) { getInstance().getGenericFB().bind(); } } }; DhApiBeforeGenericObjectRenderEvent beforeDrawEvent = new DhApiBeforeGenericObjectRenderEvent() { @Override public void beforeRender(DhApiCancelableEventParam dhApiCancelableEventParam) { if (dhApiCancelableEventParam.value.resourceLocationPath.equalsIgnoreCase("Clouds")) { if (getInstance().avoidRenderingClouds()) { dhApiCancelableEventParam.cancelEvent(); } } } }; DhApi.events.bind(DhApiBeforeGenericRenderSetupEvent.class, beforeRenderEvent); DhApi.events.bind(DhApiBeforeGenericObjectRenderEvent.class, beforeDrawEvent); } private static DHCompatInternal getInstance() { return Iris.getPipelineManager().getPipeline().map(WorldRenderingPipeline::getDHCompat).map(DHCompat::getInstance).orElse(DHCompatInternal.SHADERLESS); } private static void setupCreateDepthTextureEvent() { DhApiColorDepthTextureCreatedEvent beforeRenderEvent = new DhApiColorDepthTextureCreatedEvent() { @Override public void onResize(DhApiEventParam input) { textureWidth = input.value.newWidth; textureHeight = input.value.newHeight; } }; DhApi.events.bind(DhApiColorDepthTextureCreatedEvent.class, beforeRenderEvent); } private static void setupTransparentRendererEventCancling() { DhApiBeforeRenderEvent beforeRenderEvent = new DhApiBeforeRenderEvent() { @Override public void beforeRender(DhApiCancelableEventParam event) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered() && (!getInstance().shouldOverrideShadow)) { event.cancelEvent(); } } }; DhApiBeforeDeferredRenderEvent beforeRenderEvent2 = new DhApiBeforeDeferredRenderEvent() { @Override public void beforeRender(DhApiCancelableEventParam event) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered() && (!getInstance().shouldOverrideShadow)) { event.cancelEvent(); } } }; DhApi.events.bind(DhApiBeforeRenderEvent.class, beforeRenderEvent); DhApi.events.bind(DhApiBeforeDeferredRenderEvent.class, beforeRenderEvent2); } private static void setupBeforeRenderCleanupEvent() { DhApiBeforeRenderCleanupEvent beforeCleanupEvent = new DhApiBeforeRenderCleanupEvent() { @Override public void beforeCleanup(DhApiEventParam event) { popDhMatrices(); if (getInstance().shouldOverride) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { getInstance().getShadowShader().unbind(); } else { getInstance().getSolidShader().unbind(); if (atTranslucent) { GLStateManager.enableCull(); } } } } }; DhApi.events.bind(DhApiBeforeRenderCleanupEvent.class, beforeCleanupEvent); } private static void setupBeforeBufferClearEvent() { DhApiBeforeTextureClearEvent beforeCleanupEvent = new DhApiBeforeTextureClearEvent() { @Override public void beforeClear(DhApiCancelableEventParam event) { if (event.value.renderPass == EDhApiRenderPass.OPAQUE) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { event.cancelEvent(); } else if (getInstance().shouldOverride) { GLStateManager.glClear(GL11.GL_DEPTH_BUFFER_BIT); event.cancelEvent(); } } } }; DhApi.events.bind(DhApiBeforeTextureClearEvent.class, beforeCleanupEvent); } private static void beforeBufferRenderEvent() { DhApiBeforeBufferRenderEvent beforeCleanupEvent = new DhApiBeforeBufferRenderEvent() { @Override public void beforeRender(DhApiEventParam input) { DHCompatInternal instance = getInstance(); if (instance.shouldOverride) { DhApiVec3f modelPos = input.value.modelPos; if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { instance.getShadowShader().bind(); instance.getShadowShader().setModelPos(modelPos); } else if (atTranslucent) { instance.getTranslucentShader().bind(); instance.getTranslucentShader().setModelPos(modelPos); } else { instance.getSolidShader().bind(); instance.getSolidShader().setModelPos(modelPos); } } } }; DhApi.events.bind(DhApiBeforeBufferRenderEvent.class, beforeCleanupEvent); } private static void setupBeforeRenderFrameBufferBinding() { DhApiBeforeRenderSetupEvent beforeRenderPassEvent = new DhApiBeforeRenderSetupEvent() { @Override public void beforeSetup(DhApiEventParam event) { DHCompatInternal instance = getInstance(); OverrideInjector.INSTANCE.unbind(IDhApiShadowCullingFrustum.class, (IDhApiOverrideable) ShadowRenderer.FRUSTUM); OverrideInjector.INSTANCE.unbind(IDhApiFramebuffer.class, instance.getShadowFBWrapper()); OverrideInjector.INSTANCE.unbind(IDhApiFramebuffer.class, instance.getSolidFBWrapper()); OverrideInjector.INSTANCE.unbind(IDhApiGenericObjectShaderProgram.class, instance.getGenericShader()); if (instance.shouldOverride) { if (instance.getGenericShader() != null) { OverrideInjector.INSTANCE.bind(IDhApiGenericObjectShaderProgram.class, instance.getGenericShader()); } if (ShadowRenderingState.areShadowsCurrentlyBeingRendered() && instance.shouldOverrideShadow) { OverrideInjector.INSTANCE.bind(IDhApiFramebuffer.class, instance.getShadowFBWrapper()); OverrideInjector.INSTANCE.bind(IDhApiShadowCullingFrustum.class, (IDhApiOverrideable) ShadowRenderer.FRUSTUM); } else { OverrideInjector.INSTANCE.bind(IDhApiFramebuffer.class, instance.getSolidFBWrapper()); } } } }; DhApi.events.bind(DhApiBeforeRenderSetupEvent.class, beforeRenderPassEvent); } private static void setupBeforeRenderPassEvent() { DhApiBeforeRenderPassEvent beforeCleanupEvent = new DhApiBeforeRenderPassEvent() { @Override public void beforeRender(DhApiEventParam event) { DHCompatInternal instance = getInstance(); // config overrides if (instance.shouldOverride) { DhApi.Delayed.configs.graphics().ambientOcclusion().enabled().setValue(false); DhApi.Delayed.configs.graphics().fog().drawMode().setValue(EDhApiFogDrawMode.FOG_DISABLED); if (event.value.renderPass == EDhApiRenderPass.OPAQUE_AND_TRANSPARENT) { Iris.logger.error("Unexpected; somehow the Opaque + Translucent pass ran with shaders on."); } } else { DhApi.Delayed.configs.graphics().ambientOcclusion().enabled().clearValue(); DhApi.Delayed.configs.graphics().fog().drawMode().clearValue(); } // cleanup if (event.value.renderPass == EDhApiRenderPass.OPAQUE) { if (instance.shouldOverride) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { instance.getShadowShader().bind(); } else { instance.getSolidShader().bind(); } atTranslucent = false; } } // opaque if (event.value.renderPass == EDhApiRenderPass.OPAQUE) { float partialTicks = event.value.partialTicks; if (instance.shouldOverride) { if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { instance.getShadowShader().fillUniformData( ShadowRenderer.PROJECTION, ShadowRenderer.MODELVIEW, WORLD_MIN_Y, partialTicks); } else { Matrix4f projection = RenderingState.INSTANCE.getProjectionMatrix();; instance.getSolidShader().fillUniformData( tempMat4.setPerspective(projection.perspectiveFov(), projection.m11() / projection.m00(), event.value.nearClipPlane, event.value.farClipPlane), RenderingState.INSTANCE.getModelViewMatrix(), WORLD_MIN_Y, partialTicks); } } } // transparent if (event.value.renderPass == EDhApiRenderPass.TRANSPARENT) { float partialTicks = event.value.partialTicks; int depthTextureId = DhApi.Delayed.renderProxy.getDhDepthTextureId().payload; if (instance.shouldOverrideShadow && ShadowRenderingState.areShadowsCurrentlyBeingRendered()) { instance.getShadowShader().bind(); instance.getShadowFB().bind(); atTranslucent = true; return; } if (instance.shouldOverride && instance.getTranslucentFB() != null) { instance.copyTranslucents(textureWidth, textureHeight); instance.getTranslucentShader().bind(); Matrix4f projection = RenderingState.INSTANCE.getProjectionMatrix(); GLStateManager.disableCull(); instance.getTranslucentShader().fillUniformData( new Matrix4f().setPerspective(projection.perspectiveFov(), projection.m11() / projection.m00(), event.value.nearClipPlane, event.value.farClipPlane), RenderingState.INSTANCE.getModelViewMatrix(), WORLD_MIN_Y, partialTicks); instance.getTranslucentFB().bind(); } atTranslucent = true; } } }; DhApi.events.bind(DhApiBeforeRenderPassEvent.class, beforeCleanupEvent); } private static void setupBeforeApplyShaderEvent() { DhApiBeforeApplyShaderRenderEvent beforeApplyShaderEvent = new DhApiBeforeApplyShaderRenderEvent() { @Override public void beforeRender(DhApiCancelableEventParam event) { if (IrisApi.getInstance().isShaderPackInUse()) { DHCompatInternal instance = getInstance(); OverrideInjector.INSTANCE.unbind(IDhApiShadowCullingFrustum.class, (IDhApiOverrideable) ShadowRenderer.FRUSTUM); OverrideInjector.INSTANCE.unbind(IDhApiFramebuffer.class, instance.getShadowFBWrapper()); OverrideInjector.INSTANCE.unbind(IDhApiFramebuffer.class, instance.getSolidFBWrapper()); event.cancelEvent(); } } }; DhApi.events.bind(DhApiBeforeApplyShaderRenderEvent.class, beforeApplyShaderEvent); } }