package net.coderbot.iris.pipeline; import com.gtnewhorizons.angelica.glsm.DisplayListManager; import com.gtnewhorizons.angelica.iris.IrisDisplayListState; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import com.google.common.primitives.Ints; import com.gtnewhorizons.angelica.compat.mojang.Camera; import com.gtnewhorizons.angelica.config.AngelicaConfig; import com.gtnewhorizons.angelica.glsm.GLDebug; import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix3f; import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix4f; import org.joml.Matrix3f; import org.joml.Matrix4fc; import com.gtnewhorizons.angelica.glsm.GLStateManager; import com.gtnewhorizons.angelica.glsm.RenderSystem; import com.gtnewhorizons.angelica.glsm.ffp.Instancing; import com.gtnewhorizons.angelica.glsm.hooks.BatchStateGuard; import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks; import com.gtnewhorizons.angelica.glsm.hooks.PendingProgramSelection; import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache; import com.gtnewhorizons.angelica.rendering.RenderingState; import com.gtnewhorizons.angelica.rendering.tesr.BatchEligibility; import com.gtnewhorizons.angelica.rendering.tesr.TesrInstancingPipeline; import it.unimi.dsi.fastutil.ints.Int2ObjectArrayMap; import it.unimi.dsi.fastutil.objects.Object2ObjectMap; import net.coderbot.iris.Iris; import net.coderbot.iris.block_rendering.BlockMaterialMapping; import net.coderbot.iris.block_rendering.BlockRenderingSettings; import net.coderbot.iris.celeritas.CeleritasTerrainPipeline; import net.coderbot.iris.compat.dh.DHCompat; import net.coderbot.iris.features.FeatureFlags; import net.coderbot.iris.gbuffer_overrides.matching.InputAvailability; import net.coderbot.iris.gbuffer_overrides.matching.ProgramTable; import net.coderbot.iris.gbuffer_overrides.matching.RenderCondition; import net.coderbot.iris.gbuffer_overrides.matching.TranslucentBlendMatcher; import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition; import net.coderbot.iris.gbuffer_overrides.state.RenderTargetStateListener; import net.coderbot.iris.gl.blending.AlphaTestOverride; import net.coderbot.iris.gl.blending.BlendModeOverride; import net.coderbot.iris.gl.blending.DepthColorStorage; import net.coderbot.iris.gl.blending.BufferBlendOverride; import net.coderbot.iris.gl.buffer.ShaderStorageBufferHolder; import net.coderbot.iris.gl.buffer.ShaderStorageInfo; import net.coderbot.iris.gl.framebuffer.GlFramebuffer; import net.coderbot.iris.gl.image.GlImage; import net.coderbot.iris.gl.image.ImageHolder; import net.coderbot.iris.gl.image.ImageInformation; import net.coderbot.iris.gl.program.ComputeProgram; import net.coderbot.iris.gl.program.Program; import net.coderbot.iris.gl.program.ProgramBuilder; import net.coderbot.iris.gl.program.ProgramImages; import net.coderbot.iris.gl.program.ProgramSamplers; import net.coderbot.iris.gl.sampler.SamplerHolder; import net.coderbot.iris.gl.state.FogMode; import com.gtnewhorizons.angelica.glsm.texture.DepthBufferFormat; import com.gtnewhorizons.angelica.glsm.texture.TextureType; import net.coderbot.iris.helpers.Tri; import net.coderbot.iris.layer.GbufferPrograms; import net.coderbot.iris.pipeline.transform.GlintScrollInjector; import net.coderbot.iris.pipeline.transform.PatchShaderType; import net.coderbot.iris.pipeline.transform.TransformPatcher; import net.coderbot.iris.postprocess.BufferFlipper; import net.coderbot.iris.postprocess.CenterDepthSampler; import net.coderbot.iris.postprocess.CompositeRenderer; import net.coderbot.iris.postprocess.FinalPassRenderer; import net.coderbot.iris.postprocess.FullScreenQuadRenderer; import net.coderbot.iris.postprocess.ProgramBuildContext; import net.coderbot.iris.rendertarget.IRenderTargetExt; import net.coderbot.iris.rendertarget.ParityFlipState; import net.coderbot.iris.rendertarget.NativeImageBackedSingleColorTexture; import net.coderbot.iris.rendertarget.RenderTargets; import net.coderbot.iris.samplers.IrisImages; import net.coderbot.iris.samplers.IrisSamplers; import net.coderbot.iris.shaderpack.CloudSetting; import net.coderbot.iris.shaderpack.ComputeSource; import net.coderbot.iris.shaderpack.OptionalBoolean; import net.coderbot.iris.shaderpack.ParticleRenderingSettings; import net.coderbot.iris.shaderpack.PackDirectives; import net.coderbot.iris.shaderpack.PackShadowDirectives; import net.coderbot.iris.shaderpack.ProgramDirectives; import net.coderbot.iris.shaderpack.ProgramFallbackResolver; import net.coderbot.iris.shaderpack.ProgramSet; import net.coderbot.iris.shaderpack.ProgramSource; import net.coderbot.iris.shaderpack.loading.ProgramGroup; import net.coderbot.iris.shaderpack.loading.ProgramId; import net.coderbot.iris.shaderpack.texture.TextureStage; import net.coderbot.iris.shadows.ShadowCompositeRenderer; import net.coderbot.iris.shadows.ShadowRenderTargets; import net.coderbot.iris.texture.format.TextureFormat; import net.coderbot.iris.texture.format.TextureFormatLoader; import net.coderbot.iris.texture.pbr.PBRTextureHolder; import net.coderbot.iris.texture.pbr.PBRTextureManager; import net.coderbot.iris.texture.pbr.PBRType; import net.coderbot.iris.uniforms.CommonUniforms; import net.coderbot.iris.uniforms.FrameUpdateNotifier; import net.coderbot.iris.uniforms.ItemMaterialHelper; import net.coderbot.iris.uniforms.custom.CustomUniforms; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.EntityRenderer; import net.minecraft.client.renderer.OpenGlHelper; import net.minecraft.client.renderer.texture.AbstractTexture; import net.minecraft.client.shader.Framebuffer; import net.minecraft.profiler.Profiler; import org.apache.commons.lang3.tuple.Pair; import org.jetbrains.annotations.Nullable; import org.joml.Vector3d; import org.joml.Vector4f; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL13; import org.lwjgl.opengl.GL30; import org.lwjgl.opengl.GL42; import org.lwjgl.opengl.GL43; import org.taumc.glsl.ShaderParser; import org.taumc.glsl.Transformer; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.OptionalInt; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.function.IntFunction; import java.util.function.Supplier; /** * Encapsulates the compiled shader program objects for the currently loaded shaderpack. */ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, RenderTargetStateListener, TesrInstancingPipeline, PendingProgramSelection { private final RenderTargets renderTargets; @Nullable private ShadowRenderTargets shadowRenderTargets; @Nullable private ComputeProgram[] shadowComputes; @Nullable private ComputeProgram shadowVoxelizationCompute; private final Supplier shadowTargetsSupplier; private final ProgramTable table; private ImmutableList clearPassesFull; private ImmutableList clearPasses; private ImmutableList shadowClearPasses; private ImmutableList shadowClearPassesFull; private final ComputeProgram[] setup; private final CompositeRenderer beginRenderer; private final CompositeRenderer prepareRenderer; @Nullable private final ShadowRenderer shadowRenderer; @Nullable private final ShadowCompositeRenderer shadowCompositeRenderer; private final CustomUniforms customUniforms; private final int shadowMapResolution; private final CompositeRenderer deferredRenderer; private final CompositeRenderer compositeRenderer; private final FinalPassRenderer finalPassRenderer; private final CustomTextureManager customTextureManager; private final AbstractTexture whitePixel; private final FrameUpdateNotifier updateNotifier; private final CenterDepthSampler centerDepthSampler; private final ImmutableSet flippedBeforeShadow; private final ImmutableSet flippedAfterPrepare; private final ImmutableSet flippedAfterTranslucent; private final CeleritasTerrainPipeline celeritasTerrainPipeline; private final DHCompat dhCompat; // Custom images and SSBOs private final Set customImages; private final VertexWriteReplays vertexWriteReplays = new VertexWriteReplays(); private final GlImage[] imagesToClear; @Nullable private final ShaderStorageBufferHolder ssboHolder; private final Map, Map> attributeTransforms; private final EnumMap, Map>> instancedAttributeTransforms = new EnumMap<>(Instancing.class); private final boolean[] supportsInstancing = initialInstancingSupport(); private final ParityFlipState parityState = new ParityFlipState(AngelicaConfig.shaderParityFlip); private final Supplier> flippedGbuffers; private final Supplier> flippedShadowGbuffers; private final Supplier> flippedAfterPrepareResolved; private final Supplier> flippedBeforeShadowResolved; private final HorizonRenderer horizonRenderer = new HorizonRenderer(); private final float sunPathRotation; private final CloudSetting cloudSetting; private final boolean shouldRenderUnderwaterOverlay; private final boolean shouldRenderVignette; private final boolean supportsEndFlash; private final boolean shouldRenderSun; private final boolean shouldRenderMoon; private final boolean shouldRenderStars; private final boolean shouldRenderSkyDisc; private final boolean shouldRenderWeather; private final boolean shouldRenderWeatherParticles; private final boolean shouldWriteRainAndSnowToDepthBuffer; private final boolean shouldRenderParticlesBeforeDeferred; private final boolean shouldRenderPrepareBeforeShadow; private final boolean oldLighting; private final boolean allowConcurrentCompute; private final OptionalInt forcedShadowRenderDistanceChunks; private final CloudSetting dhCloudSetting; private Pass current = null; private RenderCondition currentCondition = null; private WorldRenderingPhase overridePhase = null; private WorldRenderingPhase phase = WorldRenderingPhase.NONE; private WorldRenderingPhase pushedPhase = WorldRenderingPhase.NONE; private boolean worldGroupActive = false; private boolean isBeforeTranslucent; private boolean isRenderingShadow = false; private InputAvailability inputs = InputAvailability.of(false, false); private SpecialCondition special = null; private boolean shouldBindPBR; private int currentNormalTexture; private int currentSpecularTexture; private PackDirectives packDirectives; private final Set activeFeatures; private final ProgramFallbackResolver resolver; private int packSamplerUsage; private final Profiler profiler = Minecraft.getMinecraft().mcProfiler; private static final Vector4f EMPTY_CLEAR_COLOR = new Vector4f(1.0F); public DeferredWorldRenderingPipeline(ProgramSet programs) { try { Objects.requireNonNull(programs); final long _t0 = System.nanoTime(); long _tLast = _t0; final int entryTextureUnit = GLStateManager.getActiveTextureUnit(); GLStateManager.glActiveTexture(GL13.GL_TEXTURE2); customTextureManager = new CustomTextureManager(programs.getPackDirectives(), programs.getPack().getCustomTextureDataMap(), programs.getPack().getIrisCustomTextureDataMap(), programs.getPack().getCustomNoiseTexture()); GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + entryTextureUnit); final Map>> prepareTransformFutures = submitCompositeTransforms(programs.getPrepare(), TextureStage.PREPARE, programs.getPackDirectives().getTextureMap()); final Map>> deferredTransformFutures = submitCompositeTransforms(programs.getDeferred(), TextureStage.DEFERRED, programs.getPackDirectives().getTextureMap()); final Map>> compositeTransformFutures = submitCompositeTransforms(programs.getComposite(), TextureStage.COMPOSITE_AND_FINAL, programs.getPackDirectives().getTextureMap()); final CompletableFuture> finalTransformFuture = programs.getCompositeFinal() .filter(ProgramSource::isValid) .map(source -> submitCompositeTransform(source, TextureStage.COMPOSITE_AND_FINAL, programs.getPackDirectives().getTextureMap())) .orElse(null); resolver = new ProgramFallbackResolver(programs); final Map mvBuiltinsMemo = new ConcurrentHashMap<>(); final Map, CompletableFuture>> attributeTransformFutures = submitAttributeTransforms(resolver, attributeProgramIds(Instancing.NONE), Instancing.NONE, mvBuiltinsMemo); final EnumMap, CompletableFuture>>> instancedTransformFutures = new EnumMap<>(Instancing.class); for (Instancing kind : Instancing.VALUES) { if (kind != Instancing.NONE) { instancedTransformFutures.put(kind, submitAttributeTransforms(resolver, attributeProgramIds(kind), kind, mvBuiltinsMemo)); } } final Optional terrainSource = first(programs.getGbuffersTerrain(), programs.getGbuffersTexturedLit(), programs.getGbuffersTextured(), programs.getGbuffersBasic()); final Optional terrainSolidOverride = programs.getGbuffersTerrainSolid(); final Optional terrainCutoutOverride = programs.getGbuffersTerrainCutout(); final Optional terrainSolidSource = first(terrainSolidOverride, terrainSource); final Optional terrainCutoutSource = first(terrainCutoutOverride, terrainSource); final Optional translucentSource = first(programs.getGbuffersWater(), terrainSource); final Optional shadowSource = programs.getShadow(); final Optional shadowSolidOverride = programs.getShadowSolid(); final Optional shadowCutoutOverride = programs.getShadowCutout(); final Optional shadowSolidSource = first(shadowSolidOverride, shadowSource); final Optional shadowCutoutSource = first(shadowCutoutOverride, shadowSource); final Optional shadowTranslucentSource = first(programs.getShadowWater(), shadowSource); // Celeritas terrain transform futures final CompletableFuture> celeritasTerrainFuture = terrainSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); final CompletableFuture> celeritasTerrainSolidFuture = terrainSolidOverride .map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasTerrainFuture); final CompletableFuture> celeritasTerrainCutoutFuture = terrainCutoutOverride .map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasTerrainFuture); final CompletableFuture> celeritasTranslucentFuture = translucentSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); final CompletableFuture> celeritasShadowFuture = shadowSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); final CompletableFuture> celeritasShadowSolidFuture = shadowSolidOverride .map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasShadowFuture); final CompletableFuture> celeritasShadowCutoutFuture = shadowCutoutOverride .map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasShadowFuture); final CompletableFuture> celeritasShadowTranslucentFuture = shadowTranslucentSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null); final Int2ObjectArrayMap> setupComputeFutures = submitSetupComputeTransforms(programs.getSetup(), programs.getPackDirectives().getTextureMap()); this.cloudSetting = programs.getPackDirectives().getCloudSetting(); this.shouldRenderUnderwaterOverlay = programs.getPackDirectives().underwaterOverlay(); this.shouldRenderVignette = programs.getPackDirectives().vignette(); this.supportsEndFlash = programs.getPackDirectives().isSupportsEndFlash(); this.shouldRenderSun = programs.getPackDirectives().shouldRenderSun(); this.shouldRenderMoon = programs.getPackDirectives().shouldRenderMoon(); this.shouldRenderStars = programs.getPackDirectives().shouldRenderStars(); this.shouldRenderSkyDisc = programs.getPackDirectives().shouldRenderSkyDisc(); this.shouldRenderWeather = programs.getPackDirectives().shouldRenderWeather(); this.shouldRenderWeatherParticles = programs.getPackDirectives().shouldRenderWeatherParticles(); this.shouldWriteRainAndSnowToDepthBuffer = programs.getPackDirectives().rainDepth(); this.dhCloudSetting = programs.getPackDirectives().getDHCloudSetting(); this.shouldRenderParticlesBeforeDeferred = programs.getPackDirectives().getParticleRenderingSettings() .map(s -> s == ParticleRenderingSettings.BEFORE || s == ParticleRenderingSettings.MIXED) .orElse(false); this.allowConcurrentCompute = programs.getPackDirectives().getConcurrentCompute(); this.shouldRenderPrepareBeforeShadow = programs.getPackDirectives().isPrepareBeforeShadow(); this.oldLighting = programs.getPackDirectives().isOldLighting(); this.updateNotifier = new FrameUpdateNotifier(); this.packDirectives = programs.getPackDirectives(); this.activeFeatures = programs.getPack().getActiveFeatures(); final Framebuffer main = Minecraft.getMinecraft().getFramebuffer(); final int depthTextureId = ((IRenderTargetExt)main).iris$getDepthTextureId(); final int internalFormat = TextureInfoCache.INSTANCE.getInfo(depthTextureId).getInternalFormat(); final DepthBufferFormat depthBufferFormat = DepthBufferFormat.fromGlEnumOrDefault(internalFormat); this.renderTargets = new RenderTargets(main.framebufferWidth, main.framebufferHeight, depthTextureId, ((IRenderTargetExt)main).iris$getDepthBufferVersion(), depthBufferFormat, programs.getPackDirectives().getRenderTargetDirectives().getRenderTargetSettings(), programs.getPackDirectives()); this.renderTargets.setParityState(parityState); this.sunPathRotation = programs.getPackDirectives().getSunPathRotation(); PackShadowDirectives shadowDirectives = programs.getPackDirectives().getShadowDirectives(); if (shadowDirectives.isDistanceRenderMulExplicit()) { if (shadowDirectives.getDistanceRenderMul() >= 0.0) { // add 15 and then divide by 16 to ensure we're rounding up forcedShadowRenderDistanceChunks = OptionalInt.of(((int) (shadowDirectives.getDistance() * shadowDirectives.getDistanceRenderMul()) + 15) / 16); } else { forcedShadowRenderDistanceChunks = OptionalInt.of(-1); } } else { forcedShadowRenderDistanceChunks = OptionalInt.empty(); } this.customUniforms = programs.getPack().customUniforms.build( holder -> CommonUniforms.addNonDynamicUniforms(holder, programs.getPack().getIdMap(), programs.getPackDirectives(), this.updateNotifier) ); final var blockIdMaps = BlockMaterialMapping.createBlockIdMaps( programs.getPack().getIdMap().getBlockProperties(), programs.getPack().getIdMap().hasLegacySection()); BlockRenderingSettings.INSTANCE.setBlockMetaMatches(blockIdMaps.blockMetaMap()); BlockRenderingSettings.INSTANCE.setBlockNbtMap(blockIdMaps.tileEntityMap()); BlockRenderingSettings.INSTANCE.setBlockTypeIds(BlockMaterialMapping.createBlockTypeMap(programs.getPack().getIdMap().getBlockRenderTypeMap())); BlockRenderingSettings.INSTANCE.setEntityIds(programs.getPack().getIdMap().getEntityIdMap()); BlockRenderingSettings.INSTANCE.setEntityNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getEntityNbtEntries())); ItemMaterialHelper.clearCache(); BlockRenderingSettings.INSTANCE.setItemIds(programs.getPack().getIdMap().getItemIdMap()); BlockRenderingSettings.INSTANCE.setItemNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getItemNbtEntries())); BlockRenderingSettings.INSTANCE.setAmbientOcclusionLevel(programs.getPackDirectives().getAmbientOcclusionLevel()); BlockRenderingSettings.INSTANCE.setDisableDirectionalShading(shouldDisableDirectionalShading()); BlockRenderingSettings.INSTANCE.setUseSeparateAo(programs.getPackDirectives().shouldUseSeparateAo()); BlockRenderingSettings.INSTANCE.setUseExtendedVertexFormat(true); // Don't clobber anything in texture unit 0. It probably won't cause issues, but we're just being cautious here. GLStateManager.glActiveTexture(GL13.GL_TEXTURE2); whitePixel = new NativeImageBackedSingleColorTexture(255, 255, 255, 255); // Initialize custom images this.customImages = new HashSet<>(); final var customImageInfos = programs.getPack().getCustomImages(); final List clearList = new ArrayList<>(); for (var entry : customImageInfos.object2ObjectEntrySet()) { final ImageInformation info = entry.getValue(); final GlImage image; if (info.isRelative()) { image = new GlImage.Relative(info.name(), info.samplerName(), info.format(), info.internalTextureFormat(), info.type(), info.clear(), info.relativeWidth(), info.relativeHeight(), main.framebufferWidth, main.framebufferHeight); } else { image = new GlImage(info.name(), info.samplerName(), info.target(), info.format(), info.internalTextureFormat(), info.type(), info.clear(), info.width(), info.height(), info.depth()); } customImages.add(image); if (image.shouldClear()) { clearList.add(image); } } this.imagesToClear = clearList.toArray(new GlImage[0]); // Initialize SSBOs final var bufferObjectInfos = programs.getPack().getBufferObjects(); if (!bufferObjectInfos.isEmpty() && RenderSystem.supportsSSBO()) { Int2ObjectArrayMap ssboOverrides = new Int2ObjectArrayMap<>(); bufferObjectInfos.forEach(ssboOverrides::put); this.ssboHolder = new ShaderStorageBufferHolder(ssboOverrides, main.framebufferWidth, main.framebufferHeight); } else { this.ssboHolder = null; } GLStateManager.glActiveTexture(GL13.GL_TEXTURE0); BufferFlipper flipper = new BufferFlipper(); this.centerDepthSampler = new CenterDepthSampler(() -> getRenderTargets().getDepthTexture(), programs.getPackDirectives().getCenterDepthHalfLife()); this.shadowMapResolution = programs.getPackDirectives().getShadowDirectives().getResolution(); this.shadowTargetsSupplier = () -> { if (shadowRenderTargets == null) { this.shadowRenderTargets = new ShadowRenderTargets(this, shadowMapResolution, shadowDirectives); } return shadowRenderTargets; }; PatchedShaderPrinter.resetPrintState(); final ProgramBuildContext beginBuildContext = new ProgramBuildContext(renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.BEGIN), customUniforms, customImages, customTextureManager.getIrisCustomTextures(), this); final ProgramBuildContext prepareBuildContext = new ProgramBuildContext(renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.PREPARE), customUniforms, customImages, customTextureManager.getIrisCustomTextures(), this); final ProgramBuildContext deferredBuildContext = new ProgramBuildContext(renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.DEFERRED), customUniforms, customImages, customTextureManager.getIrisCustomTextures(), this); final ProgramBuildContext compositeBuildContext = new ProgramBuildContext(renderTargets, customTextureManager.getNoiseTexture(), updateNotifier, centerDepthSampler, shadowTargetsSupplier, customTextureManager.getCustomTextureIdMap(TextureStage.COMPOSITE_AND_FINAL), customUniforms, customImages, customTextureManager.getIrisCustomTextures(), this); this.setup = createSetupComputes(programs.getSetup(), setupComputeFutures); Iris.logger.info("[Load #{}] DWRP phase=pre-renderers elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); this.beginRenderer = new CompositeRenderer(programs.getBegin(), programs.getBeginCompute(), flipper, beginBuildContext, programs.getPackDirectives().getExplicitFlips("begin_pre"), null, "begin", TextureStage.BEGIN); recordSamplerUsage(beginRenderer.getSamplerUsage()); Iris.logger.info("[Load #{}] DWRP renderer=begin elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); this.flippedBeforeShadow = flipper.snapshot(); this.prepareRenderer = new CompositeRenderer(programs.getPrepare(), programs.getPrepareCompute(), flipper, prepareBuildContext, programs.getPackDirectives().getExplicitFlips("prepare_pre"), prepareTransformFutures, "prepare", TextureStage.PREPARE); recordSamplerUsage(prepareRenderer.getSamplerUsage()); Iris.logger.info("[Load #{}] DWRP renderer=prepare elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); flippedAfterPrepare = flipper.snapshot(); this.deferredRenderer = new CompositeRenderer(programs.getDeferred(), programs.getDeferredCompute(), flipper, deferredBuildContext, programs.getPackDirectives().getExplicitFlips("deferred_pre"), deferredTransformFutures, "deferred", TextureStage.DEFERRED); recordSamplerUsage(deferredRenderer.getSamplerUsage()); Iris.logger.info("[Load #{}] DWRP renderer=deferred elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); flippedAfterTranslucent = flipper.snapshot(); this.compositeRenderer = new CompositeRenderer(programs.getComposite(), programs.getCompositeCompute(), flipper, compositeBuildContext, programs.getPackDirectives().getExplicitFlips("composite_pre"), compositeTransformFutures, "composite", TextureStage.COMPOSITE_AND_FINAL); recordSamplerUsage(compositeRenderer.getSamplerUsage()); Iris.logger.info("[Load #{}] DWRP renderer=composite elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); this.finalPassRenderer = new FinalPassRenderer(programs, compositeBuildContext, flipper.snapshot(), this.compositeRenderer.getFlippedAtLeastOnceFinal(), finalTransformFuture, "final"); recordSamplerUsage(finalPassRenderer.getSamplerUsage()); Iris.logger.info("[Load #{}] DWRP phase=final-renderer elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); parityState.finalizeParitySet(flipper.snapshot(), programs.getPackDirectives().getRenderTargetDirectives().getBuffersToBeCleared()); renderTargets.finalizeParity(); if (parityState.isEnabled()) { Iris.logger.info("Parity flip active for buffers {}", parityState.parityBuffers()); } this.flippedGbuffers = () -> parityState.resolve(isBeforeTranslucent ? flippedAfterPrepare : flippedAfterTranslucent); this.flippedShadowGbuffers = () -> parityState.resolve(shouldRenderPrepareBeforeShadow ? flippedAfterPrepare : flippedBeforeShadow); this.flippedAfterPrepareResolved = () -> parityState.resolve(flippedAfterPrepare); this.flippedBeforeShadowResolved = () -> parityState.resolve(flippedBeforeShadow); // [(textured=false,lightmap=false), (textured=true,lightmap=false), (textured=true,lightmap=true)] final ProgramId[] ids = new ProgramId[] { ProgramId.Basic, ProgramId.Textured, ProgramId.TexturedLit, ProgramId.SkyBasic, ProgramId.SkyTextured, ProgramId.SkyTextured, null, null, ProgramId.Terrain, null, null, ProgramId.Water, null, ProgramId.Clouds, ProgramId.Clouds, null, ProgramId.DamagedBlock, ProgramId.DamagedBlock, ProgramId.Block, ProgramId.Block, ProgramId.Block, ProgramId.BlockTrans, ProgramId.BlockTrans, ProgramId.BlockTrans, ProgramId.BeaconBeam, ProgramId.BeaconBeam, ProgramId.BeaconBeam, ProgramId.Entities, ProgramId.Entities, ProgramId.Entities, ProgramId.EntitiesTrans, ProgramId.EntitiesTrans, ProgramId.EntitiesTrans, ProgramId.Particles, ProgramId.Particles, ProgramId.Particles, ProgramId.ParticlesTrans, ProgramId.ParticlesTrans, ProgramId.ParticlesTrans, null, ProgramId.ArmorGlint, ProgramId.ArmorGlint, null, ProgramId.SpiderEyes, ProgramId.SpiderEyes, ProgramId.Hand, ProgramId.Hand, ProgramId.Hand, ProgramId.HandWater, ProgramId.HandWater, ProgramId.HandWater, null, null, ProgramId.Weather, // world border uses textured_lit even though it has no lightmap :/ null, ProgramId.TexturedLit, ProgramId.TexturedLit, ProgramId.Lightning, ProgramId.Lightning, ProgramId.Lightning, ProgramId.ShadowWater, ProgramId.ShadowWater, ProgramId.ShadowWater, ProgramId.Shadow, ProgramId.Shadow, ProgramId.Shadow }; if (ids.length != RenderCondition.values().length * 3) { throw new IllegalStateException("Program ID table length mismatch"); } this.attributeTransforms = new HashMap<>(); for (Map.Entry, CompletableFuture>> entry : attributeTransformFutures.entrySet()) { try { this.attributeTransforms.put(entry.getKey(), entry.getValue().join()); } catch (Exception e) { Iris.logger.error("Failed to transform shader: {}", entry.getKey().getLeft(), e); throw new RuntimeException("Shader transformation failed for " + entry.getKey().getLeft(), e); } } Iris.logger.info("[Load #{}] DWRP phase=attribute-join elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); for (Map.Entry, CompletableFuture>>> kindEntry : instancedTransformFutures.entrySet()) { final Instancing kind = kindEntry.getKey(); final Map, Map> joined = new HashMap<>(); this.instancedAttributeTransforms.put(kind, joined); for (Map.Entry, CompletableFuture>> entry : kindEntry.getValue().entrySet()) { try { final Map transformed = entry.getValue().join(); if (transformed == null) continue; joined.put(entry.getKey(), transformed); } catch (Exception e) { Iris.logger.warn("{} instanced transform failed for {}; disabling it", kind, entry.getKey().getLeft(), e); supportsInstancing[kind.ordinal()] = false; joined.clear(); break; } } } final Map, Pass> cachedPasses = new HashMap<>(); this.shadowComputes = createShadowComputes(programs.getShadowCompute()); final Map builtPrograms = new HashMap<>(); this.table = new ProgramTable<>((condition, availability) -> { final ProgramId finalId = gbufferProgramId(ids, condition, availability); return cachedPasses.computeIfAbsent(Pair.of(finalId, availability), p -> { final ProgramSource source = resolver.resolveNullable(p.getLeft()); if (condition == RenderCondition.SHADOW || condition == RenderCondition.SHADOW_TRANSLUCENT) { if (!shadowDirectives.isShadowEnabled().orElse(shadowRenderTargets != null)) { // shadow is not used return null; } else if (source == null) { // still need the custom framebuffer, viewport, and blend mode behavior GlFramebuffer shadowFb = shadowTargetsSupplier.get().createShadowFramebuffer(shadowRenderTargets.snapshot(), new int[] {0}); return new Pass(null, shadowFb, shadowFb, null, BlendModeOverride.OFF, Collections.emptyList(), true); } } if (source == null) { return createDefaultPass(); } try { return createPass(source, availability, condition == RenderCondition.SHADOW || condition == RenderCondition.SHADOW_TRANSLUCENT, finalId, builtPrograms); } catch (Exception e) { throw new RuntimeException("Failed to create pass for " + source.getName() + " for rendering condition " + condition + " specialized to input availability " + availability, e); } }); }); Iris.logger.info("[Load #{}] DWRP phase=gbuffer-table elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); if (shadowRenderTargets == null && shadowDirectives.isShadowEnabled() == OptionalBoolean.TRUE) { shadowRenderTargets = new ShadowRenderTargets(this, shadowMapResolution, shadowDirectives); } if (shadowRenderTargets != null) { this.shadowClearPasses = ClearPassCreator.createShadowClearPasses(shadowRenderTargets, false, shadowDirectives); this.shadowClearPassesFull = ClearPassCreator.createShadowClearPasses(shadowRenderTargets, true, shadowDirectives); this.shadowCompositeRenderer = new ShadowCompositeRenderer(this, programs.getPackDirectives(), programs.getShadowComposite(), programs.getShadowCompCompute(), this.shadowRenderTargets, ssboHolder, customTextureManager.getNoiseTexture(), updateNotifier, customTextureManager.getCustomTextureIdMap(TextureStage.SHADOWCOMP), customImages, programs.getPackDirectives().getExplicitFlips("shadowcomp_pre"), customTextureManager.getIrisCustomTextures(), customUniforms); recordSamplerUsage(shadowCompositeRenderer.getSamplerUsage()); if (programs.getPackDirectives().getShadowDirectives().isShadowEnabled().orElse(true)) { this.shadowRenderer = new ShadowRenderer(programs.getShadow().orElse(null), programs.getPackDirectives(), shadowRenderTargets, shadowCompositeRenderer, () -> usesSampler(IrisSamplers.USAGE_SHADOWTEX1)); Program shadowProgram = table.match(RenderCondition.SHADOW, SHADOW_INPUTS).getProgram(); Program shadowWaterProgram = table.match(RenderCondition.SHADOW_TRANSLUCENT, SHADOW_INPUTS).getProgram(); shadowRenderer.setUsesImages((shadowProgram != null && shadowProgram.getActiveImages() > 0) || (shadowWaterProgram != null && shadowWaterProgram.getActiveImages() > 0)); shadowRenderer.setPlayerReflectionCaptureEnabled((shadowProgram != null && GLStateManager.glGetUniformLocation(shadowProgram.getProgramId(), "playerAtlas_img") != -1) || (shadowWaterProgram != null && GLStateManager.glGetUniformLocation(shadowWaterProgram.getProgramId(), "playerAtlas_img") != -1)); } else { shadowRenderer = null; } } else { this.shadowClearPasses = ImmutableList.of(); this.shadowClearPassesFull = ImmutableList.of(); this.shadowCompositeRenderer = null; this.shadowRenderer = null; } Iris.logger.info("[Load #{}] DWRP phase=shadow elapsed_ms={}", Iris.getShaderPackLoadId(), String.format("%.1f", (System.nanoTime() - _tLast) / 1_000_000.0)); _tLast = System.nanoTime(); this.customUniforms.optimise(); this.clearPassesFull = ClearPassCreator.createClearPasses(renderTargets, true, programs.getPackDirectives().getRenderTargetDirectives()); this.clearPasses = ClearPassCreator.createClearPasses(renderTargets, false, programs.getPackDirectives().getRenderTargetDirectives()); boolean hasSetup = false; for (ComputeProgram program : setup) { if (program != null) { if (!hasSetup) { hasSetup = true; renderTargets.onFullClear(); final Vector4f fogColor = new Vector4f(1.0F, 1.0F, 1.0F, 1.0F); clearPassesFull.forEach(clearPass -> clearPass.execute(fogColor)); } program.use(); customUniforms.push(program); program.dispatch(1, 1); } } if (hasSetup) { ComputeProgram.unbind(); RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT); } // Terrain pipeline sampler/image factory setup follows. Supplier> flipped = flippedGbuffers; IntFunction createTerrainSamplers = (programId) -> { ProgramSamplers.Builder builder = ProgramSamplers.builder(programId, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureManager.getCustomTextureIdMap(TextureStage.GBUFFERS_AND_SHADOW)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, false, this); IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, InputAvailability.of(true, true)); recordSamplerUsage(IrisSamplers.addWorldDepthSamplers(customTextureSamplerInterceptor, renderTargets)); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); // Bind custom images as samplers (for texture() access to voxel_sampler, floodfill_sampler, etc.) IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); // Bind custom textures (PNG files from shader pack) IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, Objects.requireNonNull(shadowRenderTargets), null, true)); } return builder.build(); }; IntFunction createTerrainImages = (programId) -> { ProgramImages.Builder builder = ProgramImages.builder(programId); IrisImages.addRenderTargetImages(builder, flipped, renderTargets); // Bind custom images as image units (for imageLoad/imageStore) IrisImages.addCustomImages(builder, customImages); if (IrisImages.hasShadowImages(builder)) { IrisImages.addShadowColorImages(builder, Objects.requireNonNull(shadowRenderTargets), null); } return builder.build(); }; IntFunction createShadowTerrainSamplers = (programId) -> { ProgramSamplers.Builder builder = ProgramSamplers.builder(programId, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureManager.getCustomTextureIdMap(TextureStage.GBUFFERS_AND_SHADOW)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flippedAfterPrepareResolved, renderTargets, false, this); IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, InputAvailability.of(true, true)); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); // Bind custom images as samplers (for texture() access to voxel_sampler, floodfill_sampler, etc.) IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); // Bind custom textures (PNG files from shader pack) IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); // Only initialize these samplers if the shadow map renderer exists. Otherwise, this program shouldn't be used at all? if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, Objects.requireNonNull(shadowRenderTargets), null, true)); } return builder.build(); }; IntFunction createShadowTerrainImages = (programId) -> { ProgramImages.Builder builder = ProgramImages.builder(programId); IrisImages.addRenderTargetImages(builder, flippedAfterPrepareResolved, renderTargets); // Bind custom images as image units (for imageLoad/imageStore - voxelization uses this in shadow pass) IrisImages.addCustomImages(builder, customImages); if (IrisImages.hasShadowImages(builder)) { IrisImages.addShadowColorImages(builder, Objects.requireNonNull(shadowRenderTargets), null); } return builder.build(); }; final GlFramebuffer celeritasShadowFb = (shadowRenderTargets != null && shadowRenderer != null) ? shadowRenderTargets.createShadowFramebuffer(shadowRenderTargets.snapshot(), new int[] {0, 1}) : null; this.celeritasTerrainPipeline = new CeleritasTerrainPipeline(createTerrainSamplers, shadowRenderer == null ? null : createShadowTerrainSamplers, createTerrainImages, shadowRenderer == null ? null : createShadowTerrainImages, this.customUniforms, terrainSolidSource, terrainCutoutSource, translucentSource, shadowSolidSource, shadowCutoutSource, shadowTranslucentSource, celeritasTerrainSolidFuture, celeritasTerrainCutoutFuture, celeritasTranslucentFuture, celeritasShadowSolidFuture, celeritasShadowCutoutFuture, celeritasShadowTranslucentFuture, renderTargets, flippedAfterPrepare, flippedAfterTranslucent, celeritasShadowFb); this.dhCompat = new DHCompat(this, shadowDirectives.isDhShadowEnabled().orElse(true)); this.shadowVoxelizationCompute = createShadowVoxelizationCompute(); bindVoxelizationMatrixUniforms(); } catch (Throwable failure) { try { destroy(); } catch (Throwable cleanupFailure) { failure.addSuppressed(cleanupFailure); } throw failure; } } private RenderTargets getRenderTargets() { return renderTargets; } private void recordSamplerUsage(int mask) { packSamplerUsage |= mask; } private boolean usesSampler(int bit) { return (packSamplerUsage & bit) != 0; } private void checkWorld() { // If we're not in a world, then obviously we cannot possibly be rendering a world. if (Minecraft.getMinecraft().theWorld == null) { isRenderingWorld = false; current = null; } } @Override public boolean shouldDisableVanillaEntityShadows() { // OptiFine seems to disable vanilla shadows when the shaderpack uses shadow mapping? return shadowRenderer != null; } @Override public boolean shouldDisableDirectionalShading() { return !oldLighting; } @Override public CloudSetting getCloudSetting() { return cloudSetting; } @Override public boolean shouldRenderUnderwaterOverlay() { return shouldRenderUnderwaterOverlay; } @Override public boolean shouldRenderVignette() { return shouldRenderVignette; } @Override public boolean supportsEndFlash() { return supportsEndFlash; } @Override public boolean shouldRenderSun() { return shouldRenderSun; } @Override public boolean shouldRenderMoon() { return shouldRenderMoon; } @Override public boolean shouldRenderStars() { return shouldRenderStars; } @Override public boolean shouldRenderSkyDisc() { return shouldRenderSkyDisc; } @Override public boolean shouldRenderWeather() { return shouldRenderWeather; } @Override public boolean shouldRenderWeatherParticles() { return shouldRenderWeatherParticles; } @Override public boolean shouldWriteRainAndSnowToDepthBuffer() { return shouldWriteRainAndSnowToDepthBuffer; } @Override public boolean shouldRenderParticlesBeforeDeferred() { return shouldRenderParticlesBeforeDeferred; } public boolean shouldSeparateEntityDraws() { return packDirectives.shouldUseSeparateEntityDraws(); } @Override public boolean allowConcurrentCompute() { return allowConcurrentCompute; } @Override public float getSunPathRotation() { return sunPathRotation; } @Override public boolean hasFeature(FeatureFlags flag) { return activeFeatures.contains(flag); } @Override public Object2ObjectMap, String> getTextureMap() { return packDirectives.getTextureMap(); } private RenderCondition getCondition(WorldRenderingPhase phase) { if (isRenderingShadow) { return switch (phase) { case TERRAIN_TRANSLUCENT, TRIPWIRE -> RenderCondition.SHADOW_TRANSLUCENT; default -> RenderCondition.SHADOW; }; } if (special != null) { if (special == SpecialCondition.BEACON_BEAM) { return RenderCondition.BEACON_BEAM; } else if (special == SpecialCondition.ENTITY_EYES) { return RenderCondition.ENTITY_EYES; } else if (special == SpecialCondition.GLINT) { return RenderCondition.GLINT; } else if (special == SpecialCondition.LIGHTNING) { return RenderCondition.LIGHTNING; } } switch (phase) { case NONE, OUTLINE, DEBUG: return RenderCondition.DEFAULT; case PARTICLES: return isTranslucentDraw() ? RenderCondition.PARTICLES_TRANSLUCENT : RenderCondition.PARTICLES; case SKY, SUNSET, CUSTOM_SKY, SUN, MOON, STARS, VOID: return RenderCondition.SKY; case TERRAIN_SOLID, TERRAIN_CUTOUT, TERRAIN_CUTOUT_MIPPED: return RenderCondition.TERRAIN_OPAQUE; case ENTITIES: return isTranslucentDraw() ? RenderCondition.ENTITIES_TRANSLUCENT : RenderCondition.ENTITIES; case BLOCK_ENTITIES: return isTranslucentDraw() ? RenderCondition.BLOCK_ENTITIES_TRANSLUCENT : RenderCondition.BLOCK_ENTITIES; case DESTROY: return RenderCondition.DESTROY; case HAND_SOLID: return RenderCondition.HAND_OPAQUE; case TERRAIN_TRANSLUCENT, TRIPWIRE: return RenderCondition.TERRAIN_TRANSLUCENT; case CLOUDS: return RenderCondition.CLOUDS; case RAIN_SNOW: return RenderCondition.RAIN_SNOW; case HAND_TRANSLUCENT: return RenderCondition.HAND_TRANSLUCENT; case WORLD_BORDER: return RenderCondition.WORLD_BORDER; default: throw new IllegalStateException("Unknown render phase " + phase); } } private boolean isTranslucentDraw() { return declaredTranslucent != null ? declaredTranslucent : TranslucentBlendMatcher.matchesCurrentState(); } public boolean shouldOverrideShaders() { return isRenderingLevelGeometry() && isMainBound; } public boolean isRenderingLevelGeometry() { return isRenderingWorld && !isRenderingFullScreenPass && !isPostChain; } public Pass getActivePassProgram() { return current; } public int getActivePassProgramId() { if (current == null) return -1; final Program p = current.getProgram(); return p != null ? p.getProgramId() : -1; } /** * Called when a mod overrides the GL program away from the active Iris pass */ public void onModProgramOverride() { if (current != null) { modProgramOverrode = true; programBeforeModOverride = getActivePassProgramId(); } current = null; currentCondition = null; clearPendingSelection(); } public void restorePassAfterModProgram(int newProgram) { if (refreshingPass || drivingProgram || !modProgramOverrode) { return; } if (newProgram != 0 && newProgram != programBeforeModOverride) { return; } refreshingPass = true; try { current = null; matchPass(); } finally { modProgramOverrode = false; programBeforeModOverride = -1; refreshingPass = false; } } private boolean refreshingPass; private boolean modProgramOverrode; private int programBeforeModOverride = -1; public void onVanillaBlendChanged() { if (matchingBlend || drivingProgram || refreshingPass) { return; } if (declaredTranslucent != null) { return; } final WorldRenderingPhase phase = getPhase(); if (phase != WorldRenderingPhase.ENTITIES && phase != WorldRenderingPhase.BLOCK_ENTITIES) { return; } matchingBlend = true; try { requestMatch(); } finally { matchingBlend = false; } } private boolean matchingBlend; private void requestMatch() { if (DisplayListManager.getRecordMode() == DisplayListManager.RecordMode.COMPILE) return; if (GLStateManager.isForeignDraw() || BatchEligibility.batchingAllowed()) { GLSMHooks.pendingProgramSelection = this; return; } matchPass(); } @Override public void resolvePendingProgram() { if (GLSMHooks.pendingProgramSelection == this && !GLStateManager.isForeignDraw()) { matchPass(); } } private void clearPendingSelection() { if (GLSMHooks.pendingProgramSelection == this) { GLSMHooks.pendingProgramSelection = null; } } private void matchPass() { clearPendingSelection(); if (!shouldOverrideShaders()) { return; } matchPass(getCondition(getPhase())); } private void matchPass(RenderCondition condition) { if (DisplayListManager.getRecordMode() == DisplayListManager.RecordMode.COMPILE) return; currentCondition = condition; beginPass(table.match(condition, inputsFor(condition))); } /** * Shadow passes always get the lightmap attribute: every vertex format they submit carries the lightmap * element, while the live {@code inputs} flag tracks whether unit 1 has GL_TEXTURE_2D enabled - which the * shadow pass never does. Keep this consistent with the shadow program lookups in the constructor. */ private InputAvailability inputsFor(RenderCondition condition) { if (condition == RenderCondition.SHADOW || condition == RenderCondition.SHADOW_TRANSLUCENT) { return SHADOW_INPUTS; } return inputs; } /** Availability used for every shadow pass draw and for the shadow program lookups at load time. */ private static final InputAvailability SHADOW_INPUTS = InputAvailability.of(true, true); @Override public void onEntityRenderBoundary() { GLSMHooks.resolvePendingProgram(); if (!shouldOverrideShaders()) { return; } final RenderCondition condition = getCondition(getPhase()); if (condition != currentCondition) { matchPass(condition); } } public void beginPass(Pass pass) { IrisDisplayListState.runProgramTransition(() -> beginPassNow(pass)); } private void beginPassNow(Pass pass) { if (current == pass) { return; } if (current != null) { current.stopUsing(); } current = pass; drivingProgram = true; try { if (pass != null) { pass.use(); } else { Program.unbind(); } } finally { drivingProgram = false; } } private boolean drivingProgram; private Instancing activeInstancing = Instancing.NONE; @Override public void rebindCurrentPass() { activeInstancing = Instancing.NONE; GLSMHooks.resolvePendingProgram(); final Pass pass = this.current; if (pass == null) { if (GLStateManager.getActiveProgram() == 0) { matchPass(); } return; } final Program program = pass.getProgram(); final GlFramebuffer expected = isBeforeTranslucent ? pass.framebufferBeforeTranslucents : pass.framebufferAfterTranslucents; if (program != null && GLStateManager.getActiveProgram() == program.getProgramId() && GLStateManager.getDrawFramebuffer() == expected.getId()) { return; } pass.use(); } private Pass createDefaultPass() { final GlFramebuffer framebufferBeforeTranslucents = renderTargets.createGbufferFramebuffer(flippedAfterPrepare, new int[] {0}); final GlFramebuffer framebufferAfterTranslucents = renderTargets.createGbufferFramebuffer(flippedAfterTranslucent, new int[] {0}); return new Pass(null, framebufferBeforeTranslucents, framebufferAfterTranslucents, null, null, Collections.emptyList(), false); } private static ProgramId gbufferProgramId(ProgramId[] ids, RenderCondition condition, InputAvailability availability) { final int idx; if (availability.texture && availability.lightmap) { idx = 2; } else if (availability.texture) { idx = 1; } else { idx = 0; } final ProgramId id = ids[condition.ordinal() * 3 + idx]; return id != null ? id : ids[idx]; } private record SharedProgramKey(String sourceName, InputAvailability availability, boolean shadow) {} private record BuiltProgram(Program program, Pass firstPass) {} private static ProgramBuilder beginBuilder(String name, Map transformed) { final String vertex = transformed.get(PatchShaderType.VERTEX); final String geometry = transformed.get(PatchShaderType.GEOMETRY); final String tessControl = transformed.get(PatchShaderType.TESS_CONTROL); final String tessEval = transformed.get(PatchShaderType.TESS_EVAL); final String fragment = transformed.get(PatchShaderType.FRAGMENT); PatchedShaderPrinter.debugPatchedShaders(name, vertex, geometry, tessControl, tessEval, fragment); return ProgramBuilder.begin(name, vertex, geometry, tessControl, tessEval, fragment, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); } private Pass createPass(ProgramSource source, InputAvailability availability, boolean shadow, ProgramId id, Map builtPrograms) { // Use pre-computed transform if available, otherwise transform synchronously Pair key = Pair.of(source.getName(), availability); Map transformed = attributeTransforms.get(key); // The synchronous fallback below depends on the program id, so only precomputed programs are shared final SharedProgramKey shareKey = transformed != null ? new SharedProgramKey(source.getName(), availability, shadow) : null; final BuiltProgram shared = shareKey != null ? builtPrograms.get(shareKey) : null; if (shared != null) { final Pass pass = createPassInner(shared.program(), source.getDirectives(), shadow, id); this.customUniforms.mapPassLike(shared.firstPass(), pass); pass.setInstancingKey(source.getName(), availability, shadow); return pass; } if (transformed == null) { // Fallback to synchronous transform if not pre-computed String vertex = source.getVertexSource().orElseThrow(NullPointerException::new); final boolean scrollGlint = GlintScrollInjector.shouldInject(id, source); transformed = TransformPatcher.patchAttributes( vertex, source.getGeometrySource().orElse(null), source.getTessControlSource().orElse(null), source.getTessEvalSource().orElse(null), source.getFragmentSource().orElseThrow(NullPointerException::new), availability, scrollGlint); } ProgramBuilder builder = beginBuilder(source.getName(), transformed); wireGbufferProgram(builder, availability, shadow); final Program program = builder.build(); vertexWriteReplays.attach(source.getName(), program, transformed, (samplers, images) -> wireGbufferResources(samplers, images, availability, shadow)); final Pass pass = createPassInner(program, source.getDirectives(), shadow, id); this.customUniforms.mapholderToPass(builder, pass); pass.setInstancingKey(source.getName(), availability, shadow); if (shareKey != null) { builtPrograms.put(shareKey, new BuiltProgram(program, pass)); } return pass; } private void wireGbufferProgram(ProgramBuilder builder, InputAvailability availability, boolean shadow) { CommonUniforms.addDynamicUniforms(builder, FogMode.PER_VERTEX); this.customUniforms.assignTo(builder); wireGbufferResources(builder, builder, availability, shadow); } private void wireGbufferResources(SamplerHolder samplers, ImageHolder images, InputAvailability availability, boolean shadow) { final Supplier> flipped = shadow ? flippedShadowGbuffers : flippedGbuffers; TextureStage textureStage = TextureStage.GBUFFERS_AND_SHADOW; ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(samplers, customTextureManager.getCustomTextureIdMap(textureStage)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, false, this); IrisImages.addRenderTargetImages(images, flipped, renderTargets); if (!shouldBindPBR) { shouldBindPBR = IrisSamplers.hasPBRSamplers(customTextureSamplerInterceptor); } IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, availability); if (!shadow) { recordSamplerUsage(IrisSamplers.addWorldDepthSamplers(customTextureSamplerInterceptor, renderTargets)); } IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); IrisImages.addCustomImages(images, customImages); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { if (!shadow) { shadowTargetsSupplier.get(); } if (shadowRenderTargets != null) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, shadowRenderTargets, null, true)); IrisImages.addShadowColorImages(images, shadowRenderTargets, null); } } } private Pass createPassInner(Program program, ProgramDirectives programDirectives, boolean shadow, ProgramId id) { GlFramebuffer framebufferBeforeTranslucents; GlFramebuffer framebufferAfterTranslucents; if (shadow) { final int[] shadowDrawBuffers = programDirectives.hasUnknownDrawBuffers() ? new int[] { 0, 1 } : programDirectives.getDrawBuffers(); framebufferBeforeTranslucents = shadowTargetsSupplier.get().createShadowFramebuffer(shadowRenderTargets.snapshot(), shadowDrawBuffers); framebufferAfterTranslucents = framebufferBeforeTranslucents; } else { framebufferBeforeTranslucents = renderTargets.createGbufferFramebuffer(flippedAfterPrepare, programDirectives.getDrawBuffers()); framebufferAfterTranslucents = renderTargets.createGbufferFramebuffer(flippedAfterTranslucent, programDirectives.getDrawBuffers()); } AlphaTestOverride alphaTestOverride = programDirectives.getAlphaTestOverride() .orElse(id.getDefaultAlphaTestOverride()); List bufferOverrides = new ArrayList<>(); programDirectives.getBufferBlendOverrides().forEach(information -> { int index = Ints.indexOf(programDirectives.getDrawBuffers(), information.getIndex()); if (index > -1) { bufferOverrides.add(new BufferBlendOverride(index, information.getBlendMode())); } }); return new Pass(program, framebufferBeforeTranslucents, framebufferAfterTranslucents, alphaTestOverride, programDirectives.getBlendModeOverride().orElse(id.getBlendModeOverride()), bufferOverrides, shadow); } public void addGbufferOrShadowSamplers(SamplerHolder samplers, ImageHolder images, Supplier> flipped, boolean isShadowPass, boolean hasTexture, boolean hasLightmap, boolean hasOverlay) { TextureStage textureStage = TextureStage.GBUFFERS_AND_SHADOW; ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(samplers, customTextureManager.getCustomTextureIdMap(textureStage)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, false, this); IrisImages.addRenderTargetImages(images, flipped, renderTargets); if (!shouldBindPBR) { shouldBindPBR = IrisSamplers.hasPBRSamplers(customTextureSamplerInterceptor); } IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, InputAvailability.of(hasTexture, hasLightmap)); if (!isShadowPass) { recordSamplerUsage(IrisSamplers.addWorldDepthSamplers(customTextureSamplerInterceptor, renderTargets)); } IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); IrisImages.addCustomImages(images, customImages); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, shadowTargetsSupplier.get(), null, true)); } if (isShadowPass || IrisImages.hasShadowImages(images)) { IrisImages.addShadowColorImages(images, shadowTargetsSupplier.get(), null); } } private boolean isPostChain; private boolean isMainBound = true; @Override public void beginPostChain() { isPostChain = true; beginPass(null); } @Override public void endPostChain() { isPostChain = false; } @Override public void setIsMainBound(boolean bound) { isMainBound = bound; if (!isRenderingWorld || isRenderingFullScreenPass || isPostChain) { return; } if (bound) { // force refresh current = null; } else { beginPass(null); } } public CloudSetting getDHCloudSetting() { return dhCloudSetting; } public Optional getDHTerrainShader() { return resolver.resolve(ProgramId.DhTerrain); } public Optional getDHGenericShader() { return resolver.resolve(ProgramId.DhGeneric); } public Optional getDHWaterShader() { return resolver.resolve(ProgramId.DhWater); } public Optional getDHShadowShader() { return resolver.resolve(ProgramId.DhShadow); } public CustomUniforms getCustomUniforms() { return customUniforms; } public GlFramebuffer createDHFramebuffer(ProgramSource sources, boolean trans) { return renderTargets.createDHFramebuffer(trans ? flippedAfterTranslucent : flippedAfterPrepare, sources.getDirectives().getDrawBuffers()); } public ImmutableSet getFlippedBeforeShadow() { return parityState.resolve(flippedBeforeShadow); } public ImmutableSet getFlippedAfterPrepare() { return parityState.resolve(flippedAfterPrepare); } public ImmutableSet getFlippedAfterTranslucent() { return parityState.resolve(flippedAfterTranslucent); } public GlFramebuffer createDHFramebufferShadow(ProgramSource sources) { return shadowRenderTargets.createDHFramebuffer(ImmutableSet.of(), new int[]{0, 1}); } public boolean hasShadowRenderTargets() { return shadowRenderTargets != null; } public final class Pass { @Nullable private final Program program; private final GlFramebuffer framebufferBeforeTranslucents; private final GlFramebuffer framebufferAfterTranslucents; @Nullable private final AlphaTestOverride alphaTestOverride; @Nullable private final BlendModeOverride blendModeOverride; @Nullable private final List bufferBlendOverrides; private final boolean shadowViewport; private String instancingSourceName; private InputAvailability instancingAvailability; private boolean instancingShadow; private final Program[] instancedVariants = new Program[Instancing.VALUES.length]; private final boolean[] instancedVariantAttempted = new boolean[Instancing.VALUES.length]; private Pass(@Nullable Program program, GlFramebuffer framebufferBeforeTranslucents, GlFramebuffer framebufferAfterTranslucents, @Nullable AlphaTestOverride alphaTestOverride, @Nullable BlendModeOverride blendModeOverride, @Nullable List bufferBlendOverrides, boolean shadowViewport) { this.program = program; this.framebufferBeforeTranslucents = framebufferBeforeTranslucents; this.framebufferAfterTranslucents = framebufferAfterTranslucents; this.alphaTestOverride = alphaTestOverride; this.blendModeOverride = blendModeOverride; this.bufferBlendOverrides = bufferBlendOverrides; this.shadowViewport = shadowViewport; } public void use() { IrisDisplayListState.runProgramTransition(this::useNow); } private void useNow() { DepthColorStorage.unlockDepthColor(); if (isBeforeTranslucent) { framebufferBeforeTranslucents.bind(); } else { framebufferAfterTranslucents.bind(); } if (shadowViewport) { GLStateManager.glViewport(0, 0, shadowMapResolution, shadowMapResolution); } else { final Framebuffer main = Minecraft.getMinecraft().getFramebuffer(); GLStateManager.glViewport(0, 0, main.framebufferWidth, main.framebufferHeight); } // Apply state overrides before program.use() so that uniforms (e.g. iris_currentAlphaTest) // read the correct GLSM state during upload, not the stale vanilla state. if (alphaTestOverride != null) { alphaTestOverride.apply(); } else { // Previous program on the stack might have applied an override AlphaTestOverride.restore(); } if (blendModeOverride != null) { blendModeOverride.apply(); } else { // Previous program on the stack might have applied an override BlendModeOverride.restore(); } if (bufferBlendOverrides != null && !bufferBlendOverrides.isEmpty()) { bufferBlendOverrides.forEach(BufferBlendOverride::apply); } if (activeInstancing != Instancing.NONE && program != null) { DeferredWorldRenderingPipeline.this.bindInstancedVariant(activeInstancing); } else { if (program != null) program.use(); DeferredWorldRenderingPipeline.this.customUniforms.push(this); } } public void stopUsing() { DepthColorStorage.unlockDepthColor(); if (alphaTestOverride != null) { AlphaTestOverride.restore(); } if (blendModeOverride != null || (bufferBlendOverrides != null && !bufferBlendOverrides.isEmpty())) { BlendModeOverride.restore(); } } @Nullable public Program getProgram() { return program; } void setInstancingKey(String sourceName, InputAvailability availability, boolean shadow) { this.instancingSourceName = sourceName; this.instancingAvailability = availability; this.instancingShadow = shadow; } @Nullable Program instancedVariant(Instancing kind) { final int i = kind.ordinal(); if (!instancedVariantAttempted[i]) { instancedVariantAttempted[i] = true; if (instancingSourceName != null && supportsInstancing[i]) { instancedVariants[i] = sharedInstancedVariant(instancingSourceName, instancingAvailability, instancingShadow, kind); } } return instancedVariants[i]; } public void destroy() { if (this.program != null) { this.program.destroy(); } for (int i = 0; i < instancedVariants.length; i++) { if (instancedVariants[i] != null) { instancedVariants[i].destroy(); instancedVariants[i] = null; } } } } private record InstancedVariantKey(String sourceName, InputAvailability availability, boolean shadow, Instancing kind) {} // Passes sharing a program also share its instanced variants private final Map instancedVariantPrograms = new HashMap<>(); @Nullable private Program sharedInstancedVariant(String sourceName, InputAvailability availability, boolean shadow, Instancing kind) { final InstancedVariantKey key = new InstancedVariantKey(sourceName, availability, shadow, kind); if (instancedVariantPrograms.containsKey(key)) return instancedVariantPrograms.get(key); final Program variant = buildInstancedVariant(sourceName, availability, shadow, kind); instancedVariantPrograms.put(key, variant); return variant; } @Nullable private Program buildInstancedVariant(String sourceName, InputAvailability availability, boolean shadow, Instancing kind) { final Map, Map> transforms = instancedAttributeTransforms.get(kind); final Map transformed = transforms != null ? transforms.get(Pair.of(sourceName, availability)) : null; if (transformed == null) { return null; } try { final ProgramBuilder builder = beginBuilder(sourceName + kind.variantSuffix, transformed); wireGbufferProgram(builder, availability, shadow); final Program variant = builder.build(); vertexWriteReplays.attach(sourceName + kind.variantSuffix, variant, transformed, (samplers, images) -> wireGbufferResources(samplers, images, availability, shadow)); this.customUniforms.mapholderToPass(builder, variant); return variant; } catch (Exception e) { Iris.logger.warn("{} instanced variant link failed for {}; disabling it", kind, sourceName, e); supportsInstancing[kind.ordinal()] = false; return null; } } static boolean[] initialInstancingSupport() { final boolean[] out = new boolean[Instancing.VALUES.length]; out[Instancing.TEMPLATE.ordinal()] = true; out[Instancing.CUBE.ordinal()] = AngelicaConfig.cubeInstancingEnabled(); out[Instancing.PARTICLE.ordinal()] = true; out[Instancing.WEATHER.ordinal()] = true; return out; } public boolean supportsInstancing(Instancing kind) { return supportsInstancing[kind.ordinal()]; } @Override public boolean hasInstancedVariant(Instancing kind) { return current != null && current.instancedVariant(kind) != null; } @Override public void bindInstancedVariant(Instancing kind) { activeInstancing = kind; final Program variant = current.instancedVariant(kind); variant.use(); this.customUniforms.push(variant); } @Override public void destroy() { clearPendingSelection(); DepthColorStorage.unlockDepthColor(); BlendModeOverride.restore(); AlphaTestOverride.restore(); GLStateManager.enableAlphaTest(); GLStateManager.glAlphaFunc(GL11.GL_GREATER, 0.1f); GLStateManager.glDepthFunc(GL11.GL_LEQUAL); GLStateManager.incrementFragmentGeneration(); FullScreenQuadRenderer.clearLocCache(); // Every field below can still be null when the constructor failed partway if (table != null) { destroyPasses(table); } // Destroy the composite rendering pipeline // // This destroys all the loaded composite programs as well. if (beginRenderer != null) beginRenderer.destroy(); if (prepareRenderer != null) prepareRenderer.destroy(); if (compositeRenderer != null) compositeRenderer.destroy(); if (deferredRenderer != null) deferredRenderer.destroy(); if (finalPassRenderer != null) finalPassRenderer.destroy(); if (centerDepthSampler != null) centerDepthSampler.destroy(); // Destroy setup compute programs if (setup != null) { for (ComputeProgram compute : setup) { if (compute != null) { compute.destroy(); } } } // Destroy shadow compute programs if (shadowComputes != null) { for (ComputeProgram compute : shadowComputes) { if (compute != null) { compute.destroy(); } } } vertexWriteReplays.destroy(); if (shadowVoxelizationCompute != null) { shadowVoxelizationCompute.destroy(); shadowVoxelizationCompute = null; } // Destroy shadow composite renderer if (shadowCompositeRenderer != null) { shadowCompositeRenderer.destroy(); } horizonRenderer.destroy(); // Make sure that any custom framebuffers are not bound before destroying render targets OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_READ_FRAMEBUFFER, 0); OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_DRAW_FRAMEBUFFER, 0); OpenGlHelper.func_153171_g/*glBindFramebuffer*/(GL30.GL_FRAMEBUFFER, 0); Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(false); // Destroy our render targets // // While it's possible to just clear them instead and reuse them, we'd need to investigate whether or not this // would help performance. if (renderTargets != null) renderTargets.destroy(); if (dhCompat != null) dhCompat.clearPipeline(); // destroy the shadow render targets if (shadowRenderTargets != null) { shadowRenderTargets.destroy(); } // Destroy custom textures and the static samplers (normals, specular, and noise) if (customTextureManager != null) customTextureManager.destroy(); if (whitePixel != null) whitePixel.deleteGlTexture(); // Destroy custom images if (customImages != null) { for (GlImage image : customImages) { image.destroy(); } customImages.clear(); } // Destroy SSBOs if (ssboHolder != null) { ssboHolder.destroyBuffers(); } } public void compileInstancedVariants() { final Set visited = new HashSet<>(); table.forEach(pass -> { if (pass == null || !visited.add(pass)) return; for (Instancing kind : Instancing.VALUES) { if (kind != Instancing.NONE) pass.instancedVariant(kind); } }); } private static void destroyPasses(ProgramTable table) { Set destroyed = new HashSet<>(); table.forEach(pass -> { if (pass == null) { return; } if (destroyed.contains(pass)) { return; } pass.destroy(); destroyed.add(pass); }); } private void prepareRenderTargets() { parityState.onFrameStart(); // Make sure we're using texture unit 0 for this. GLStateManager.glActiveTexture(GL13.GL_TEXTURE0); if (shadowRenderTargets != null) { profiler.startSection("iris_shadow_clear"); if (packDirectives.getShadowDirectives().isShadowEnabled() == OptionalBoolean.FALSE) { if (shadowRenderTargets.isFullClearRequired()) { shadowRenderTargets.onFullClear(); for (ClearPass clearPass : shadowClearPassesFull) { clearPass.execute(EMPTY_CLEAR_COLOR); } } } else { // Clear depth first, regardless of any color clearing. shadowRenderTargets.getDepthSourceFb().bind(); GLStateManager.glClear(GL11.GL_DEPTH_BUFFER_BIT); ImmutableList passes; for (ComputeProgram computeProgram : shadowComputes) { if (computeProgram != null) { computeProgram.use(); this.customUniforms.push(computeProgram); computeProgram.dispatch(shadowMapResolution, shadowMapResolution); } } if (shadowRenderTargets.isFullClearRequired()) { passes = shadowClearPassesFull; shadowRenderTargets.onFullClear(); } else { passes = shadowClearPasses; } for (ClearPass clearPass : passes) { clearPass.execute(EMPTY_CLEAR_COLOR); } } profiler.endSection(); } profiler.startSection("iris_clear"); final Framebuffer main = Minecraft.getMinecraft().getFramebuffer(); final int depthTextureId = ((IRenderTargetExt)main).iris$getDepthTextureId(); final int internalFormat = TextureInfoCache.INSTANCE.getInfo(depthTextureId).getInternalFormat(); final DepthBufferFormat depthBufferFormat = DepthBufferFormat.fromGlEnumOrDefault(internalFormat); final boolean changed = renderTargets.resizeIfNeeded(((IRenderTargetExt)main).iris$getDepthBufferVersion(), depthTextureId, main.framebufferWidth, main.framebufferHeight, depthBufferFormat, packDirectives); if (changed) { profiler.startSection("iris_clear_resize"); beginRenderer.recalculateSizes(); prepareRenderer.recalculateSizes(); deferredRenderer.recalculateSizes(); compositeRenderer.recalculateSizes(); finalPassRenderer.recalculateSwapPassSize(); this.clearPassesFull.forEach(clearPass -> renderTargets.destroyFramebuffer(clearPass.getFramebuffer())); this.clearPasses.forEach(clearPass -> renderTargets.destroyFramebuffer(clearPass.getFramebuffer())); this.clearPassesFull = ClearPassCreator.createClearPasses(renderTargets, true, packDirectives.getRenderTargetDirectives()); this.clearPasses = ClearPassCreator.createClearPasses(renderTargets, false, packDirectives.getRenderTargetDirectives()); // Resize custom images if needed for (GlImage image : customImages) { image.updateNewSize(main.framebufferWidth, main.framebufferHeight); } // Resize SSBOs if needed if (ssboHolder != null) { ssboHolder.hasResizedScreen(main.framebufferWidth, main.framebufferHeight); } // Re-run setup computes after resize (SETUP dispatches with 1,1 workgroups) boolean ranSetup = false; for (ComputeProgram program : setup) { if (program != null) { ranSetup = true; program.use(); customUniforms.push(program); program.dispatch(1, 1); } } if (ranSetup) { ComputeProgram.unbind(); RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT); } profiler.endSection(); } final ImmutableList passes; if (renderTargets.isFullClearRequired()) { renderTargets.onFullClear(); parityState.reset(); passes = clearPassesFull; } else { passes = clearPasses; } final Vector3d fogColor3 = GLStateManager.getFogColor(); // NB: The alpha value must be 1.0 here, or else you will get a bunch of bugs. Sildur's Vibrant Shaders // will give you pink reflections and other weirdness if this is zero. final Vector4f fogColor = new Vector4f((float) fogColor3.x, (float) fogColor3.y, (float) fogColor3.z, 1.0F); for (ClearPass clearPass : passes) { clearPass.execute(fogColor); } // Reset framebuffer and viewport Minecraft.getMinecraft().getFramebuffer().bindFramebuffer(true); profiler.endSection(); } @Nullable private ComputeProgram createShadowVoxelizationCompute() { if (celeritasTerrainPipeline == null) return null; final Optional sourceOpt = celeritasTerrainPipeline.getShadowVoxelizationComputeSource(); if (sourceOpt.isEmpty()) return null; final String src = sourceOpt.get(); final ProgramBuilder builder; try { PatchedShaderPrinter.debugPatchedShaders("shadow_voxelization_compute", null, null, null, src); builder = ProgramBuilder.beginCompute("shadow_voxelization", src, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); } catch (RuntimeException e) { Iris.logger.error("Voxelization compute shader compilation failed; colored lighting will not render", e); return null; } CommonUniforms.addDynamicUniforms(builder, FogMode.PER_VERTEX); this.customUniforms.assignTo(builder); final Supplier> flipped = () -> flippedBeforeShadow; final TextureStage textureStage = TextureStage.GBUFFERS_AND_SHADOW; final ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureManager.getCustomTextureIdMap(textureStage)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, false, this); IrisImages.addRenderTargetImages(builder, flipped, renderTargets); IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, InputAvailability.of(true, true)); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor) && shadowRenderTargets != null) { IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, shadowRenderTargets, null, true); IrisImages.addShadowColorImages(builder, shadowRenderTargets, null); } customImages.stream() .sorted(Comparator.comparing(GlImage::getName)) .forEach(image -> builder.addTextureImage(image::getId, image.getInternalFormat(), image.getName())); final ComputeProgram program = builder.buildCompute(); this.customUniforms.mapholderToPass(builder, program); return program; } @Nullable public ComputeProgram getShadowVoxelizationCompute() { return shadowVoxelizationCompute; } @Nullable public ShadowRenderer getShadowRenderer() { return shadowRenderer; } private GlUniformMatrix4f voxelizationModelView; private GlUniformMatrix3f voxelizationNormalMatrix; private final Matrix3f voxelizationNormalScratch = new Matrix3f(); private void bindVoxelizationMatrixUniforms() { if (shadowVoxelizationCompute == null) return; final int id = shadowVoxelizationCompute.getProgramId(); final int modelView = GLStateManager.glGetUniformLocation(id, "iris_ModelViewMatrix"); final int normal = GLStateManager.glGetUniformLocation(id, "iris_NormalMatrix"); this.voxelizationModelView = modelView >= 0 ? new GlUniformMatrix4f(modelView) : null; this.voxelizationNormalMatrix = normal >= 0 ? new GlUniformMatrix3f(normal) : null; } public void prepareShadowVoxelizationCompute(Matrix4fc modelView) { if (shadowVoxelizationCompute == null) return; if (voxelizationModelView != null) { voxelizationModelView.set(modelView); } if (voxelizationNormalMatrix != null) { voxelizationNormalScratch.set(modelView).invert().transpose(); voxelizationNormalMatrix.set(voxelizationNormalScratch); } customUniforms.push(shadowVoxelizationCompute); } private ComputeProgram[] createShadowComputes(ComputeSource[] compute) { ComputeProgram[] programs = new ComputeProgram[compute.length]; for (int i = 0; i < programs.length; i++) { ComputeSource source = compute[i]; if (source == null || !source.getSource().isPresent()) { continue; } else { ProgramBuilder builder; try { String transformed = TransformPatcher.patchCompute(source.getName(), source.getSource().orElse(null), TextureStage.GBUFFERS_AND_SHADOW, getTextureMap()); PatchedShaderPrinter.debugPatchedShaders(source.getName() + "_compute", null, null, null, transformed); builder = ProgramBuilder.beginCompute(source.getName(), transformed, IrisSamplers.WORLD_RESERVED_TEXTURE_UNITS); } catch (RuntimeException e) { // TODO: Better error handling throw new RuntimeException("Shader compilation failed!", e); } CommonUniforms.addDynamicUniforms(builder, FogMode.PER_VERTEX); this.customUniforms.assignTo(builder); final Supplier> flipped = flippedBeforeShadowResolved; TextureStage textureStage = TextureStage.GBUFFERS_AND_SHADOW; ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureManager.getCustomTextureIdMap(textureStage)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, false, this); IrisImages.addRenderTargetImages(builder, flipped, renderTargets); IrisSamplers.addLevelSamplers(customTextureSamplerInterceptor, this, whitePixel, InputAvailability.of(true, true)); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { if (shadowRenderTargets != null) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, shadowRenderTargets, null, true)); IrisImages.addShadowColorImages(builder, shadowRenderTargets, null); } } IrisImages.addCustomImages(builder, customImages); programs[i] = builder.buildCompute(); this.customUniforms.mapholderToPass(builder, programs[i]); programs[i].setWorkGroupInfo(source.getWorkGroupRelative(), source.getWorkGroups(), null); } } return programs; } private ComputeProgram[] createSetupComputes(ComputeSource[] compute, Int2ObjectArrayMap> futures) { ComputeProgram[] programs = new ComputeProgram[compute.length]; for (int i = 0; i < programs.length; i++) { ComputeSource source = compute[i]; if (source == null || !source.getSource().isPresent()) { continue; } else { ProgramBuilder builder; try { final CompletableFuture future = futures.get(i); final String transformed = future != null ? future.join() : TransformPatcher.patchCompute(source.getName(), source.getSource().orElse(null), TextureStage.SETUP, getTextureMap()); PatchedShaderPrinter.debugPatchedShaders(source.getName() + "_compute", null, null, null, transformed); builder = ProgramBuilder.beginCompute(source.getName(), transformed, IrisSamplers.COMPOSITE_RESERVED_TEXTURE_UNITS); } catch (RuntimeException e) { throw new RuntimeException("Shader compilation failed for setup compute " + source.getName() + "!", e); } CommonUniforms.addDynamicUniforms(builder, FogMode.OFF); this.customUniforms.assignTo(builder); ImmutableSet empty = ImmutableSet.of(); Supplier> flipped = () -> empty; ProgramSamplers.CustomTextureSamplerInterceptor customTextureSamplerInterceptor = ProgramSamplers.customTextureSamplerInterceptor(builder, customTextureManager.getCustomTextureIdMap(TextureStage.SETUP)); IrisSamplers.addRenderTargetSamplers(customTextureSamplerInterceptor, flipped, renderTargets, true, this); IrisSamplers.addCustomImages(customTextureSamplerInterceptor, customImages); IrisSamplers.addCustomTextures(customTextureSamplerInterceptor, customTextureManager.getIrisCustomTextures()); IrisImages.addRenderTargetImages(builder, flipped, renderTargets); IrisImages.addCustomImages(builder, customImages); IrisSamplers.addNoiseSampler(customTextureSamplerInterceptor, customTextureManager.getNoiseTexture()); recordSamplerUsage(IrisSamplers.addCompositeSamplers(customTextureSamplerInterceptor, renderTargets)); if (IrisSamplers.hasShadowSamplers(customTextureSamplerInterceptor)) { if (shadowRenderTargets != null) { recordSamplerUsage(IrisSamplers.addShadowSamplers(customTextureSamplerInterceptor, shadowRenderTargets, null, true)); IrisImages.addShadowColorImages(builder, shadowRenderTargets, null); } } programs[i] = builder.buildCompute(); this.customUniforms.mapholderToPass(builder, programs[i]); programs[i].setWorkGroupInfo(source.getWorkGroupRelative(), source.getWorkGroups(), null); } } return programs; } @Override public void beginHand() { isRenderingFullScreenPass = true; beginPass(null); currentCondition = null; profiler.startSection("iris_center_depth"); centerDepthSampler.sampleCenterDepth(); profiler.endSection(); isRenderingFullScreenPass = false; if (!usesSampler(IrisSamplers.USAGE_DEPTHTEX2)) { return; } // We need to copy the current depth texture so that depthtex2 can contain the depth values for // all non-translucent content without the hand, as required. profiler.startSection("iris_hand_depth_copy"); renderTargets.copyPreHandDepth(); profiler.endSection(); } @Override public void beginTranslucents() { isBeforeTranslucent = false; // We need to copy the current depth texture so that depthtex1 can contain the depth values for // all non-translucent content, as required. if (usesSampler(IrisSamplers.USAGE_DEPTHTEX1)) { profiler.startSection("iris_translucent_depth_copy"); renderTargets.copyPreTranslucentDepth(); profiler.endSection(); } // needed to remove blend mode overrides and similar beginPass(null); isRenderingFullScreenPass = true; profiler.startSection("iris_deferred"); GLDebug.pushGroup("deferred"); try { deferredRenderer.renderAll(); } finally { GLDebug.popGroup(); profiler.endSection(); } GLStateManager.enableBlend(); GLStateManager.enableAlphaTest(); // note: we are careful not to touch the lightmap texture unit or overlay color texture unit here, // so we don't need to do anything to restore them if needed. // // Previous versions of the code tried to "restore" things by enabling the lightmap & overlay color // but that actually broke rendering of clouds and rain by making them appear red in the case of // a pack not overriding those shader programs. // // Not good! isRenderingFullScreenPass = false; } @Override public void renderShadows(EntityRenderer levelRenderer, Camera playerCamera) { if (shouldRenderPrepareBeforeShadow) { isRenderingFullScreenPass = true; profiler.startSection("iris_prepare_passes"); GLDebug.pushGroup("prepare"); try { prepareRenderer.renderAll(); } finally { GLDebug.popGroup(); profiler.endSection(); } isRenderingFullScreenPass = false; } if (shadowRenderer != null) { isRenderingShadow = true; matchPass(); // Ensure shadow shader is bound for entity rendering GLDebug.pushGroup("shadow"); try { shadowRenderer.renderShadows(levelRenderer, playerCamera); } finally { GLDebug.popGroup(); } // needed to remove blend mode overrides and similar beginPass(null); isRenderingShadow = false; } if (!shouldRenderPrepareBeforeShadow) { isRenderingFullScreenPass = true; profiler.startSection("iris_prepare_passes"); GLDebug.pushGroup("prepare"); try { prepareRenderer.renderAll(); } finally { GLDebug.popGroup(); profiler.endSection(); } isRenderingFullScreenPass = false; } } @Override public void addDebugText(List messages) { messages.add(""); if (shadowRenderer != null) { shadowRenderer.addDebugText(messages); } else { messages.add("[" + Iris.MODNAME + "] Shadow Maps: not used by shader pack"); } } @Override public OptionalInt getForcedShadowRenderDistanceChunksForDisplay() { return forcedShadowRenderDistanceChunks; } // TODO: better way to avoid this global state? private boolean isRenderingWorld = false; private boolean isRenderingFullScreenPass = false; @Override public void beginLevelRendering() { final Framebuffer mainFb = Minecraft.getMinecraft().getFramebuffer(); if (mainFb == null || mainFb.framebufferWidth < 16 || mainFb.framebufferHeight < 16) { return; } isRenderingFullScreenPass = false; isRenderingWorld = true; isBeforeTranslucent = true; isMainBound = true; isPostChain = false; phase = WorldRenderingPhase.NONE; overridePhase = null; // HandRenderer.INSTANCE.getBufferSource().resetDrawCalls(); checkWorld(); if (!isRenderingWorld) { Iris.logger.warn("beginWorldRender was called but we are not currently rendering a world?"); return; } if (current != null) { throw new IllegalStateException("Called beginLevelRendering but level rendering appears to still be in progress?"); } profiler.startSection("iris_uniforms"); updateNotifier.onNewFrame(); this.customUniforms.update(); // Make sure SSBO is bound if (ssboHolder != null) { ssboHolder.setupBuffers(); } profiler.endSection(); // Get ready for world rendering prepareRenderTargets(); // Clear custom images that need clearing each frame if (imagesToClear.length > 0) { profiler.startSection("iris_clear_images"); for (GlImage image : imagesToClear) { image.clear(); } profiler.endSection(); } GLDebug.pushGroup("world"); worldGroupActive = true; isRenderingFullScreenPass = true; profiler.startSection("iris_begin_passes"); GLDebug.pushGroup("begin"); try { beginRenderer.renderAll(); } finally { GLDebug.popGroup(); profiler.endSection(); } isRenderingFullScreenPass = false; setPhase(WorldRenderingPhase.SKY); // Render our horizon box before actual sky rendering to avoid being broken by mods that do weird things // while rendering the sky. // // A lot of dimension mods touch sky rendering, FabricSkyboxes injects at HEAD and cancels, etc. // DimensionSpecialEffects.SkyType skyType = Minecraft.getMinecraft().theWorld.effects().skyType(); if (true/*skyType == DimensionSpecialEffects.SkyType.NORMAL*/) { profiler.startSection("iris_horizon"); GLStateManager.glDisable(GL11.GL_TEXTURE_2D); GLStateManager.glDepthMask(false); final Vector3d fogColor = GLStateManager.getFogColor(); GLStateManager.glColor4f((float) fogColor.x, (float) fogColor.y, (float) fogColor.z, 1.0F); horizonRenderer.renderHorizon(RenderingState.INSTANCE.getModelViewBuffer()); GLStateManager.glDepthMask(true); GLStateManager.glEnable(GL11.GL_TEXTURE_2D); profiler.endSection(); } } @Override public void finalizeLevelRendering() { checkWorld(); if (!isRenderingWorld) { Iris.logger.warn("finalizeWorldRendering was called but we are not currently rendering a world?"); return; } beginPass(null); isRenderingWorld = false; phase = WorldRenderingPhase.NONE; overridePhase = null; syncPhaseDebugGroup(); isRenderingFullScreenPass = true; profiler.startSection("iris_composites"); GLDebug.pushGroup("composite"); try { compositeRenderer.renderAll(); } finally { GLDebug.popGroup(); profiler.endSection(); } profiler.startSection("iris_final_pass"); GLDebug.pushGroup("final"); try { finalPassRenderer.renderFinalPass(); } finally { GLDebug.popGroup(); profiler.endSection(); } isRenderingFullScreenPass = false; if (worldGroupActive) { GLDebug.popGroup(); worldGroupActive = false; } } @Override public CeleritasTerrainPipeline getCeleritasTerrainPipeline() { return celeritasTerrainPipeline; } @Override public FrameUpdateNotifier getFrameUpdateNotifier() { return updateNotifier; } @Override public DHCompat getDHCompat() { return dhCompat; } @Override public WorldRenderingPhase getPhase() { if (overridePhase != null) { return overridePhase; } return phase; } @Override public void setOverridePhase(WorldRenderingPhase phase) { this.overridePhase = phase; syncPhaseDebugGroup(); requestMatch(); GbufferPrograms.runPhaseChangeNotifier(); } @Override public void setPhase(WorldRenderingPhase phase) { this.phase = phase; syncPhaseDebugGroup(); requestMatch(); GbufferPrograms.runPhaseChangeNotifier(); } private static final String[] PHASE_GROUP_NAMES = buildPhaseGroupNames(); private static String[] buildPhaseGroupNames() { final WorldRenderingPhase[] phases = WorldRenderingPhase.values(); final String[] names = new String[phases.length]; for (int i = 0; i < phases.length; i++) { names[i] = "phase:" + phases[i].name(); } return names; } private void syncPhaseDebugGroup() { final WorldRenderingPhase target = overridePhase != null ? overridePhase : phase; if (target == pushedPhase) return; if (pushedPhase != WorldRenderingPhase.NONE) { GLDebug.popGroup(); } if (target != WorldRenderingPhase.NONE) { GLDebug.pushGroup(PHASE_GROUP_NAMES[target.ordinal()]); } pushedPhase = target; } @Override public void setInputs(InputAvailability availability) { this.inputs = availability; requestMatch(); } @Override public void setSpecialCondition(SpecialCondition special) { this.special = special; requestMatch(); } @Override public void setDeclaredTranslucency(@Nullable Boolean translucent) { this.declaredTranslucent = translucent; requestMatch(); } @Nullable private Boolean declaredTranslucent; @Override public RenderTargetStateListener getRenderTargetStateListener() { return this; } @Override public int getCurrentNormalTexture() { return currentNormalTexture; } @Override public int getCurrentSpecularTexture() { return currentSpecularTexture; } @Override public void onBindTexture(int id) { if (shouldBindPBR && isRenderingWorld) { final PBRTextureHolder pbrHolder = PBRTextureManager.INSTANCE.getOrLoadHolder(id); currentNormalTexture = pbrHolder.getNormalTexture().getGlTextureId(); currentSpecularTexture = pbrHolder.getSpecularTexture().getGlTextureId(); BatchStateGuard.suspend(); try { final TextureFormat textureFormat = TextureFormatLoader.getFormat(); if (textureFormat != null) { textureFormat.setupTextureParameters(PBRType.NORMAL, pbrHolder.getNormalTexture()); textureFormat.setupTextureParameters(PBRType.SPECULAR, pbrHolder.getSpecularTexture()); } PBRTextureManager.notifyPBRTexturesChanged(); } finally { BatchStateGuard.resume(); } } } private static CompletableFuture> submitCompositeTransform(ProgramSource source, TextureStage stage, Object2ObjectMap, String> textureMap) { return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchComposite( source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getTessControlSource().orElse(null), source.getTessEvalSource().orElse(null), source.getFragmentSource().orElse(null), stage, textureMap)); } private static Map>> submitCompositeTransforms(ProgramSource[] sources, TextureStage stage, Object2ObjectMap, String> textureMap) { // Count valid sources for initial capacity int count = 0; for (ProgramSource source : sources) { if (source != null && source.isValid()) count++; } final Map>> futures = new HashMap<>(count); for (int i = 0; i < sources.length; i++) { if (sources[i] != null && sources[i].isValid()) { futures.put(i, submitCompositeTransform(sources[i], stage, textureMap)); } } return futures; } private static Map, CompletableFuture>> submitAttributeTransforms(ProgramFallbackResolver resolver, ProgramId[] ids, Instancing instancing, Map mvBuiltinsMemo) { if (instancing == Instancing.CUBE && !AngelicaConfig.cubeInstancingEnabled()) { return Collections.emptyMap(); } final boolean instanced = instancing != Instancing.NONE; final boolean matrixInstanced = instancing.hasInstanceHead(); final Map, CompletableFuture>> futures = new HashMap<>(); final Set processedSourceNames = new HashSet<>(); for (ProgramId id : ids) { if (id.getGroup() == ProgramGroup.Dh) continue; final ProgramSource source = resolver.resolveNullable(id); if (source == null || !processedSourceNames.add(source.getName())) { continue; } final String vertexSource = source.getVertexSource().orElse(null); final boolean scrollGlint = GlintScrollInjector.shouldInject(id, source); for (InputAvailability avail : InputAvailability.VALUES) { futures.put(Pair.of(source.getName(), avail), Iris.ShaderTransformExecutor.submitTracked(() -> { if (matrixInstanced && mvBuiltinsMemo.computeIfAbsent(source.getName(), k -> { final boolean references = referencesMvBuiltinsOutsideVertex(source); if (references) { Iris.logger.info("TESR instancing: {} references MV builtins outside the vertex stage, keeping CPU path", k); } return references; })) { return null; } final String geometry = source.getGeometrySource().orElse(null); final String tessControl = source.getTessControlSource().orElse(null); final String tessEval = source.getTessEvalSource().orElse(null); final String fragment = source.getFragmentSource().orElse(null); return instanced ? TransformPatcher.patchAttributesInstanced(vertexSource, geometry, tessControl, tessEval, fragment, avail, scrollGlint, instancing) : TransformPatcher.patchAttributes(vertexSource, geometry, tessControl, tessEval, fragment, avail, scrollGlint); })); } } return futures; } private static final ProgramId[] INSTANCED_PROGRAM_IDS = { ProgramId.Block, ProgramId.BlockTrans, ProgramId.Entities, ProgramId.EntitiesTrans, ProgramId.Shadow, ProgramId.ShadowWater, ProgramId.ArmorGlint }; private static final ProgramId[] PARTICLE_PROGRAM_IDS = { ProgramId.Particles, ProgramId.ParticlesTrans }; private static final ProgramId[] WEATHER_PROGRAM_IDS = { ProgramId.Weather }; private static ProgramId[] attributeProgramIds(Instancing kind) { return switch (kind) { case NONE -> ProgramId.values(); case TEMPLATE, CUBE -> INSTANCED_PROGRAM_IDS; case PARTICLE -> PARTICLE_PROGRAM_IDS; case WEATHER -> WEATHER_PROGRAM_IDS; }; } private static final String[] MV_BUILTINS = { "gl_ModelViewMatrix", "gl_ModelViewMatrixInverse", "gl_ModelViewProjectionMatrix", "gl_ModelViewProjectionMatrixInverse", "gl_NormalMatrix", "ftransform" }; static boolean referencesMvBuiltins(String source) { if (source == null) { return false; } boolean mentioned = false; for (String builtin : MV_BUILTINS) { if (source.contains(builtin)) { mentioned = true; break; } } if (!mentioned) { return false; } try { final Transformer transformer = new Transformer(ShaderParser.parseShader(source).full()); for (String builtin : MV_BUILTINS) { if (transformer.containsCall(builtin)) { return true; } } return false; } catch (Exception e) { return true; } } private static boolean referencesMvBuiltinsOutsideVertex(ProgramSource source) { return referencesMvBuiltins(source.getGeometrySource().orElse(null)) || referencesMvBuiltins(source.getTessControlSource().orElse(null)) || referencesMvBuiltins(source.getTessEvalSource().orElse(null)) || referencesMvBuiltins(source.getFragmentSource().orElse(null)); } private static CompletableFuture> submitCeleritasTerrainTransform(ProgramSource source) { return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchCeleritasTerrain(source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getFragmentSource().orElse(null))); } private static Int2ObjectArrayMap> submitSetupComputeTransforms(ComputeSource[] compute, Object2ObjectMap, String> textureMap) { if (compute == null) return new Int2ObjectArrayMap<>(0); final Int2ObjectArrayMap> futures = new Int2ObjectArrayMap<>(compute.length); for (int i = 0; i < compute.length; i++) { final ComputeSource source = compute[i]; if (source == null || !source.getSource().isPresent()) continue; final String name = source.getName(); final String src = source.getSource().get(); futures.put(i, Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchCompute(name, src, TextureStage.SETUP, textureMap))); } return futures; } @SafeVarargs private static Optional first(Optional... candidates) { for (Optional candidate : candidates) { if (candidate.isPresent()) { return candidate; } } return Optional.empty(); } public static void warmupTransforms(ProgramSet programs) { final Object2ObjectMap, String> tm = programs.getPackDirectives().getTextureMap(); submitCompositeTransforms(programs.getPrepare(), TextureStage.PREPARE, tm); submitCompositeTransforms(programs.getDeferred(), TextureStage.DEFERRED, tm); submitCompositeTransforms(programs.getComposite(), TextureStage.COMPOSITE_AND_FINAL, tm); programs.getCompositeFinal().filter(ProgramSource::isValid) .ifPresent(source -> submitCompositeTransform(source, TextureStage.COMPOSITE_AND_FINAL, tm)); final ProgramFallbackResolver resolver = new ProgramFallbackResolver(programs); final Map mvBuiltinsMemo = new ConcurrentHashMap<>(); for (Instancing kind : Instancing.VALUES) { submitAttributeTransforms(resolver, attributeProgramIds(kind), kind, mvBuiltinsMemo); } final Optional terrainSource = first(programs.getGbuffersTerrain(), programs.getGbuffersTexturedLit(), programs.getGbuffersTextured(), programs.getGbuffersBasic()); final Optional translucentSource = first(programs.getGbuffersWater(), terrainSource); final Optional shadowSource = programs.getShadow(); final Optional shadowTranslucentSource = first(programs.getShadowWater(), shadowSource); terrainSource.ifPresent(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform); translucentSource.ifPresent(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform); shadowSource.ifPresent(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform); shadowTranslucentSource.ifPresent(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform); submitSetupComputeTransforms(programs.getSetup(), tm); final ComputeSource[] shadowCompute = programs.getShadowCompute(); if (shadowCompute != null) { for (final ComputeSource source : shadowCompute) { if (source == null || !source.getSource().isPresent()) continue; final String name = source.getName(); final String src = source.getSource().get(); Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchCompute(name, src, TextureStage.GBUFFERS_AND_SHADOW, tm)); } } } }