mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-18 03:25:17 +00:00
408 lines
19 KiB
Java
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);
|
|
}
|
|
|
|
|
|
}
|