mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-17 19:15:06 +00:00
215 lines
8.7 KiB
Java
215 lines
8.7 KiB
Java
package net.coderbot.iris.celeritas;
|
|
|
|
import com.gtnewhorizons.angelica.glsm.GLStateManager;
|
|
import com.gtnewhorizons.angelica.mixins.interfaces.EntityRendererAccessor;
|
|
import net.coderbot.iris.Iris;
|
|
import net.coderbot.iris.gl.blending.BlendModeOverride;
|
|
import net.coderbot.iris.gl.blending.BufferBlendOverride;
|
|
import net.coderbot.iris.gl.framebuffer.GlFramebuffer;
|
|
import net.coderbot.iris.gl.program.ProgramImages;
|
|
import net.coderbot.iris.gl.program.ProgramSamplers;
|
|
import net.coderbot.iris.gl.program.ProgramUniforms;
|
|
import net.coderbot.iris.pipeline.WorldRenderingPipeline;
|
|
import net.coderbot.iris.samplers.IrisSamplers;
|
|
import net.coderbot.iris.shadows.ShadowRenderingState;
|
|
import net.coderbot.iris.uniforms.custom.CustomUniforms;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.renderer.texture.DynamicTexture;
|
|
import org.embeddedt.embeddium.impl.gl.shader.ShaderBindingContext;
|
|
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformFloat3v;
|
|
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix3f;
|
|
import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix4f;
|
|
import org.embeddedt.embeddium.impl.gl.tessellation.GlPrimitiveType;
|
|
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
|
|
import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderTextureSlot;
|
|
import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.joml.Matrix3f;
|
|
import org.joml.Matrix4f;
|
|
import org.joml.Matrix4fc;
|
|
import org.lwjgl.opengl.GL11;
|
|
import org.lwjgl.opengl.GL13;
|
|
|
|
import java.util.List;
|
|
|
|
public class IrisCeleritasChunkShaderInterface implements ChunkShaderInterface {
|
|
@Nullable
|
|
private final GlUniformMatrix4f uniformModelViewMatrix;
|
|
@Nullable
|
|
private final GlUniformMatrix4f uniformModelViewMatrixInverse;
|
|
@Nullable
|
|
private final GlUniformMatrix4f uniformProjectionMatrix;
|
|
@Nullable
|
|
private final GlUniformMatrix4f uniformProjectionMatrixInverse;
|
|
@Nullable
|
|
private final GlUniformMatrix3f uniformNormalMatrix;
|
|
@Nullable
|
|
private final GlUniformFloat3v uniformRegionOffset;
|
|
|
|
// Iris program state
|
|
private final ProgramUniforms irisProgramUniforms;
|
|
private final ProgramSamplers irisProgramSamplers;
|
|
private final ProgramImages irisProgramImages;
|
|
private final CustomUniforms customUniforms;
|
|
|
|
// Rendering state
|
|
private final BlendModeOverride blendModeOverride;
|
|
private final List<BufferBlendOverride> bufferBlendOverrides;
|
|
private final boolean hasOverrides;
|
|
|
|
// Stored matrices for inverse and normal matrix computation
|
|
private final Matrix4f projectionMatrixInverse = new Matrix4f();
|
|
private final Matrix4f modelViewMatrixInverse = new Matrix4f();
|
|
private final Matrix3f normalMatrix = new Matrix3f();
|
|
|
|
public IrisCeleritasChunkShaderInterface(int handle, ShaderBindingContext context, CeleritasTerrainPipeline pipeline, boolean isShadowPass, BlendModeOverride blendModeOverride, List<BufferBlendOverride> bufferBlendOverrides, CustomUniforms customUniforms) {
|
|
this.uniformModelViewMatrix = context.bindUniformIfPresent("iris_ModelViewMatrix", GlUniformMatrix4f::new);
|
|
this.uniformModelViewMatrixInverse = context.bindUniformIfPresent("iris_ModelViewMatrixInverse", GlUniformMatrix4f::new);
|
|
this.uniformProjectionMatrix = context.bindUniformIfPresent("iris_ProjectionMatrix", GlUniformMatrix4f::new);
|
|
this.uniformProjectionMatrixInverse = context.bindUniformIfPresent("iris_ProjectionMatrixInverse", GlUniformMatrix4f::new);
|
|
this.uniformNormalMatrix = context.bindUniformIfPresent("iris_NormalMatrix", GlUniformMatrix3f::new);
|
|
this.uniformRegionOffset = context.bindUniformIfPresent("u_RegionOffset", GlUniformFloat3v::new);
|
|
|
|
this.blendModeOverride = blendModeOverride;
|
|
this.bufferBlendOverrides = bufferBlendOverrides;
|
|
this.hasOverrides = bufferBlendOverrides != null && !bufferBlendOverrides.isEmpty();
|
|
this.customUniforms = customUniforms;
|
|
|
|
final ProgramUniforms.Builder builder = pipeline.initUniforms(handle);
|
|
customUniforms.mapholderToPass(builder, this);
|
|
this.irisProgramUniforms = builder.buildUniforms();
|
|
this.irisProgramSamplers = isShadowPass ? pipeline.initShadowSamplers(handle) : pipeline.initTerrainSamplers(handle);
|
|
this.irisProgramImages = isShadowPass ? pipeline.initShadowImages(handle) : pipeline.initTerrainImages(handle);
|
|
}
|
|
|
|
@Override
|
|
public void setupState(TerrainRenderPass pass) {
|
|
bindFramebuffer(pass);
|
|
|
|
if (ShadowRenderingState.areShadowsCurrentlyBeingRendered()) {
|
|
GLStateManager.disableCull();
|
|
}
|
|
|
|
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + IrisSamplers.ALBEDO_TEXTURE_UNIT);
|
|
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, Minecraft.getMinecraft().getTextureMapBlocks().getGlTextureId());
|
|
|
|
GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + IrisSamplers.LIGHTMAP_TEXTURE_UNIT);
|
|
final DynamicTexture lightmapTexture = ((EntityRendererAccessor) Minecraft.getMinecraft().entityRenderer).getLightmapTexture();
|
|
GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, lightmapTexture.getGlTextureId());
|
|
|
|
if (blendModeOverride != null) {
|
|
blendModeOverride.apply();
|
|
}
|
|
|
|
if (hasOverrides) {
|
|
bufferBlendOverrides.forEach(BufferBlendOverride::apply);
|
|
}
|
|
|
|
if (irisProgramUniforms != null) {
|
|
irisProgramUniforms.update();
|
|
}
|
|
if (irisProgramSamplers != null) {
|
|
irisProgramSamplers.update();
|
|
}
|
|
if (irisProgramImages != null) {
|
|
irisProgramImages.update();
|
|
}
|
|
|
|
customUniforms.push(this);
|
|
}
|
|
|
|
@Override
|
|
public void restoreState() {
|
|
if (blendModeOverride != null || hasOverrides) {
|
|
BlendModeOverride.restore();
|
|
}
|
|
|
|
ProgramUniforms.clearActiveUniforms();
|
|
ProgramSamplers.clearActiveSamplers();
|
|
}
|
|
|
|
@Override
|
|
public GlPrimitiveType getPrimitiveType() {
|
|
return GlPrimitiveType.TRIANGLES;
|
|
}
|
|
|
|
@Override
|
|
public void setProjectionMatrix(Matrix4fc matrix) {
|
|
if (uniformProjectionMatrix != null) {
|
|
uniformProjectionMatrix.set(matrix);
|
|
}
|
|
|
|
if (uniformProjectionMatrixInverse != null) {
|
|
projectionMatrixInverse.set(matrix);
|
|
projectionMatrixInverse.invert();
|
|
uniformProjectionMatrixInverse.set(projectionMatrixInverse);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setModelViewMatrix(Matrix4fc modelView) {
|
|
if (uniformModelViewMatrix != null) {
|
|
uniformModelViewMatrix.set(modelView);
|
|
}
|
|
|
|
if (uniformModelViewMatrixInverse != null) {
|
|
modelViewMatrixInverse.set(modelView);
|
|
modelViewMatrixInverse.invert();
|
|
uniformModelViewMatrixInverse.set(modelViewMatrixInverse);
|
|
}
|
|
|
|
if (uniformNormalMatrix != null) {
|
|
normalMatrix.set(modelView);
|
|
normalMatrix.invert();
|
|
normalMatrix.transpose();
|
|
uniformNormalMatrix.set(normalMatrix);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setRegionOffset(float x, float y, float z) {
|
|
if (uniformRegionOffset != null) {
|
|
uniformRegionOffset.set(x, y, z);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setTextureSlot(ChunkShaderTextureSlot slot, int val) {
|
|
// No-op - Iris manages texture state internally
|
|
}
|
|
|
|
private void bindFramebuffer(TerrainRenderPass pass) {
|
|
final CeleritasTerrainPipeline pipeline = getCeleritasTerrainPipeline();
|
|
if (pipeline == null) {
|
|
return;
|
|
}
|
|
|
|
final boolean isShadow = ShadowRenderingState.areShadowsCurrentlyBeingRendered();
|
|
final IrisTerrainPass irisPass;
|
|
if (isShadow) {
|
|
if (pass.isReverseOrder()) {
|
|
irisPass = IrisTerrainPass.SHADOW_TRANSLUCENT;
|
|
} else {
|
|
irisPass = pass.supportsFragmentDiscard() ? IrisTerrainPass.SHADOW_CUTOUT : IrisTerrainPass.SHADOW;
|
|
}
|
|
} else if (pass.isReverseOrder()) {
|
|
irisPass = IrisTerrainPass.GBUFFER_TRANSLUCENT;
|
|
} else if (pass.supportsFragmentDiscard()) {
|
|
irisPass = IrisTerrainPass.GBUFFER_CUTOUT;
|
|
} else {
|
|
irisPass = IrisTerrainPass.GBUFFER_SOLID;
|
|
}
|
|
|
|
final GlFramebuffer framebuffer = pipeline.getPassInfo(irisPass).framebuffer();
|
|
if (framebuffer != null) {
|
|
framebuffer.bind();
|
|
}
|
|
}
|
|
|
|
@org.jetbrains.annotations.Nullable
|
|
private CeleritasTerrainPipeline getCeleritasTerrainPipeline() {
|
|
final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
|
|
return pipeline != null ? pipeline.getCeleritasTerrainPipeline() : null;
|
|
}
|
|
}
|