Files
Angelica/src/main/java/net/coderbot/iris/compat/dh/LodRendererEvents.java
T

408 lines
19 KiB
Java

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<Void> 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<DhApiRenderParam> 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<DhApiRenderParam> 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<DhApiRenderParam> dhApiEventParam) {
if (getInstance().getGenericFB() != null) {
getInstance().getGenericFB().bind();
}
}
};
DhApiBeforeGenericObjectRenderEvent beforeDrawEvent = new DhApiBeforeGenericObjectRenderEvent() {
@Override
public void beforeRender(DhApiCancelableEventParam<EventParam> 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<EventParam> 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<DhApiRenderParam> event) {
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered() && (!getInstance().shouldOverrideShadow)) {
event.cancelEvent();
}
}
};
DhApiBeforeDeferredRenderEvent beforeRenderEvent2 = new DhApiBeforeDeferredRenderEvent() {
@Override
public void beforeRender(DhApiCancelableEventParam<DhApiRenderParam> 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<DhApiRenderParam> 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<DhApiRenderParam> 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<EventParam> 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<DhApiRenderParam> 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<DhApiRenderParam> 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<DhApiRenderParam> 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);
}
}