mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-18 11:29:08 +00:00
Packs pick parts of some blocks by where a pixel sits inside its world block (cauldron water, end portal frame eyes, brewing stands), which goes wrong for geometry drawn turned or off the grid. While a local grid is on, the camera and matrix uniforms describe a world where the draw's model space is the block grid. View space, clip space and the shadow map come out the same. Not on the SDL GPU backend. The remapping is one table in LocalGridFrame, applied where the custom uniform inputs are built, so the Iris uniform classes stay as they are. Custom uniforms the pack builds from remapped ones get evaluated again too, and smooth() smooths from the frame's starting value when it's called twice in one frame so it doesn't step twice. beginLocalGrid hands back a LocalGrid to close, and warns once if the modelview was left changed. Also adds the at_midBlock location to TerrainRendering for packs that don't need the grid.
2896 lines
116 KiB
Java
2896 lines
116 KiB
Java
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 lombok.Getter;
|
|
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.GLSMBlend;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMCurrentAttribs;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMDepthStencilAlpha;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMEnable;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMFog;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMFramebuffer;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMPrograms;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMRasterizer;
|
|
import com.gtnewhorizons.angelica.glsm.GLSMTextures;
|
|
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.profiling.Tracy;
|
|
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 me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
|
|
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.GlSampler;
|
|
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.BiFunction;
|
|
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 static final Tracy.ZoneId Z_CLIP_VARIANT = Tracy.zoneId("irisClipVariant", Tracy.COLOR_IRIS);
|
|
|
|
private final RenderTargets renderTargets;
|
|
|
|
@Nullable
|
|
private ShadowRenderTargets shadowRenderTargets;
|
|
@Nullable
|
|
private ComputeProgram[] shadowComputes;
|
|
@Nullable private ComputeProgram shadowVoxelizationCompute;
|
|
private final Supplier<ShadowRenderTargets> shadowTargetsSupplier;
|
|
|
|
private final ProgramTable<Pass> table;
|
|
|
|
private ImmutableList<ClearPass> clearPassesFull;
|
|
private ImmutableList<ClearPass> clearPasses;
|
|
private ImmutableList<ClearPass> shadowClearPasses;
|
|
private ImmutableList<ClearPass> 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<Integer> flippedBeforeShadow;
|
|
private final ImmutableSet<Integer> flippedAfterPrepare;
|
|
private final ImmutableSet<Integer> flippedAfterTranslucent;
|
|
|
|
private final CeleritasTerrainPipeline celeritasTerrainPipeline;
|
|
private final DHCompat dhCompat;
|
|
|
|
// Custom images and SSBOs
|
|
private final Set<GlImage> customImages;
|
|
private final VertexWriteReplays vertexWriteReplays = new VertexWriteReplays();
|
|
private final GlImage[] imagesToClear;
|
|
@Nullable
|
|
private final ShaderStorageBufferHolder ssboHolder;
|
|
|
|
private final Map<Pair<String, InputAvailability>, Map<PatchShaderType, String>> attributeTransforms;
|
|
private final EnumMap<Instancing, Map<Pair<String, InputAvailability>, Map<PatchShaderType, String>>> instancedAttributeTransforms = new EnumMap<>(Instancing.class);
|
|
private final boolean[] supportsInstancing = initialInstancingSupport();
|
|
private final Map<Pair<String, InputAvailability>, Map<PatchShaderType, String>> wideLineTransforms = new HashMap<>();
|
|
private final Map<WideLineKey, WideLineProgram> wideLinePrograms = new HashMap<>();
|
|
private final boolean packWidensLines;
|
|
private final ParityFlipState parityState = new ParityFlipState(AngelicaConfig.shaderParityFlip);
|
|
private final Supplier<ImmutableSet<Integer>> flippedGbuffers;
|
|
private final Supplier<ImmutableSet<Integer>> flippedShadowGbuffers;
|
|
private final Supplier<ImmutableSet<Integer>> flippedAfterPrepareResolved;
|
|
private final Supplier<ImmutableSet<Integer>> 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;
|
|
@Getter
|
|
private GlSampler normalSampler;
|
|
@Getter
|
|
private GlSampler specularSampler;
|
|
private TextureFormat samplerFormat;
|
|
private int samplerAnisotropy = -1;
|
|
private boolean samplerBreaksAnisotropy;
|
|
private PackDirectives packDirectives;
|
|
private final Set<FeatureFlags> 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 = GLSMTextures.getActiveTextureUnit();
|
|
GLSMTextures.glActiveTexture(GL13.GL_TEXTURE2);
|
|
customTextureManager = new CustomTextureManager(programs.getPackDirectives(), programs.getPack().getCustomTextureDataMap(), programs.getPack().getIrisCustomTextureDataMap(), programs.getPack().getCustomNoiseTexture());
|
|
GLSMTextures.glActiveTexture(GL13.GL_TEXTURE0 + entryTextureUnit);
|
|
|
|
final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> prepareTransformFutures =
|
|
submitCompositeTransforms(programs.getPrepare(), TextureStage.PREPARE, programs.getPackDirectives().getTextureMap());
|
|
final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> deferredTransformFutures =
|
|
submitCompositeTransforms(programs.getDeferred(), TextureStage.DEFERRED, programs.getPackDirectives().getTextureMap());
|
|
final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> compositeTransformFutures =
|
|
submitCompositeTransforms(programs.getComposite(), TextureStage.COMPOSITE_AND_FINAL, programs.getPackDirectives().getTextureMap());
|
|
|
|
final CompletableFuture<Map<PatchShaderType, String>> 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<String, Boolean> mvBuiltinsMemo = new ConcurrentHashMap<>();
|
|
final Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> attributeTransformFutures = submitAttributeTransforms(resolver, attributeProgramIds(Instancing.NONE), Instancing.NONE, mvBuiltinsMemo);
|
|
packWidensLines = programs.get(ProgramId.Line).isPresent();
|
|
final Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> wideLineTransformFutures = submitWideLineTransforms(resolver, packWidensLines);
|
|
final EnumMap<Instancing, Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>>> 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<ProgramSource> terrainSource = first(programs.getGbuffersTerrain(), programs.getGbuffersTexturedLit(), programs.getGbuffersTextured(), programs.getGbuffersBasic());
|
|
final Optional<ProgramSource> terrainSolidOverride = programs.getGbuffersTerrainSolid();
|
|
final Optional<ProgramSource> terrainCutoutOverride = programs.getGbuffersTerrainCutout();
|
|
final Optional<ProgramSource> terrainSolidSource = first(terrainSolidOverride, terrainSource);
|
|
final Optional<ProgramSource> terrainCutoutSource = first(terrainCutoutOverride, terrainSource);
|
|
|
|
final Optional<ProgramSource> translucentSource = first(programs.getGbuffersWater(), terrainSource);
|
|
final Optional<ProgramSource> shadowSource = programs.getShadow();
|
|
final Optional<ProgramSource> shadowSolidOverride = programs.getShadowSolid();
|
|
final Optional<ProgramSource> shadowCutoutOverride = programs.getShadowCutout();
|
|
final Optional<ProgramSource> shadowSolidSource = first(shadowSolidOverride, shadowSource);
|
|
final Optional<ProgramSource> shadowCutoutSource = first(shadowCutoutOverride, shadowSource);
|
|
final Optional<ProgramSource> shadowTranslucentSource = first(programs.getShadowWater(), shadowSource);
|
|
|
|
// Celeritas terrain transform futures
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasTerrainFuture = terrainSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasTerrainSolidFuture = terrainSolidOverride
|
|
.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasTerrainFuture);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasTerrainCutoutFuture = terrainCutoutOverride
|
|
.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasTerrainFuture);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasTranslucentFuture = translucentSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasShadowFuture = shadowSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasShadowSolidFuture = shadowSolidOverride
|
|
.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasShadowFuture);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasShadowCutoutFuture = shadowCutoutOverride
|
|
.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(celeritasShadowFuture);
|
|
final CompletableFuture<Map<PatchShaderType, String>> celeritasShadowTranslucentFuture = shadowTranslucentSource.map(DeferredWorldRenderingPipeline::submitCeleritasTerrainTransform).orElse(null);
|
|
|
|
final Int2ObjectArrayMap<CompletableFuture<String>> 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.setBreaksAnisotropy(programs.getPackDirectives().breaksAnisotropy());
|
|
BlockRenderingSettings.INSTANCE.setUseExtendedVertexFormat(true);
|
|
updatePbrSamplers(TextureFormatLoader.getFormat(), SodiumGameOptions.resolvedAnisotropicFiltering());
|
|
|
|
// Don't clobber anything in texture unit 0. It probably won't cause issues, but we're just being cautious here.
|
|
GLSMTextures.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<GlImage> 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<ShaderStorageInfo> ssboOverrides = new Int2ObjectArrayMap<>();
|
|
bufferObjectInfos.forEach(ssboOverrides::put);
|
|
this.ssboHolder = new ShaderStorageBufferHolder(ssboOverrides, main.framebufferWidth, main.framebufferHeight);
|
|
} else {
|
|
this.ssboHolder = null;
|
|
}
|
|
|
|
GLSMTextures.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.Line, ProgramId.Line, ProgramId.Line,
|
|
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<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> 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<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> entry : wideLineTransformFutures.entrySet()) {
|
|
try {
|
|
this.wideLineTransforms.put(entry.getKey(), entry.getValue().join());
|
|
} catch (Exception e) {
|
|
Iris.logger.warn("Wide line transform failed for {}; lines there stay 1 px wide!", entry.getKey().getLeft(), e);
|
|
}
|
|
}
|
|
|
|
for (Map.Entry<Instancing, Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>>> kindEntry : instancedTransformFutures.entrySet()) {
|
|
final Instancing kind = kindEntry.getKey();
|
|
final Map<Pair<String, InputAvailability>, Map<PatchShaderType, String>> joined = new HashMap<>();
|
|
this.instancedAttributeTransforms.put(kind, joined);
|
|
for (Map.Entry<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> entry : kindEntry.getValue().entrySet()) {
|
|
try {
|
|
final Map<PatchShaderType, String> 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<Pair<ProgramId, InputAvailability>, Pass> cachedPasses = new HashMap<>();
|
|
|
|
this.shadowComputes = createShadowComputes(programs.getShadowCompute());
|
|
|
|
final Map<SharedProgramKey, BuiltProgram> builtPrograms = new HashMap<>();
|
|
|
|
this.table = new ProgramTable<>((condition, requested) -> {
|
|
final InputAvailability availability = condition == RenderCondition.LINES ? LINE_INPUTS : requested;
|
|
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(usesImages(shadowProgram) || usesImages(shadowWaterProgram));
|
|
shadowRenderer.setPlayerReflectionCaptureEnabled(usesImage(shadowProgram, "playerAtlas_img") || usesImage(shadowWaterProgram, "playerAtlas_img"));
|
|
} 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<ImmutableSet<Integer>> flipped = flippedGbuffers;
|
|
|
|
IntFunction<ProgramSamplers> 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<ProgramImages> 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<ProgramSamplers> 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<ProgramImages> 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<Tri<String, TextureType, TextureStage>, 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;
|
|
}
|
|
|
|
/** Evaluates these built-in uniforms again and pushes them to the bound pass, see LocalGridFrame. */
|
|
public void refreshUniforms(String[] names) {
|
|
customUniforms.refreshInputs(names);
|
|
if (current != null && current.liveProgram != null
|
|
&& GLSMPrograms.getActiveProgram() == current.liveProgram.getProgramId()) {
|
|
current.pushCustomUniforms();
|
|
}
|
|
}
|
|
|
|
public int getActivePassProgramId() {
|
|
if (current == null) return -1;
|
|
final Program p = current.boundProgram();
|
|
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 boolean clipRebindPending;
|
|
|
|
public void onClipPlanesInUseChanged() {
|
|
if (current == null) return;
|
|
clipRebindPending = true;
|
|
GLSMHooks.pendingProgramSelection = this;
|
|
}
|
|
|
|
private void resolveClipRebind() {
|
|
if (!clipRebindPending) return;
|
|
if (DisplayListManager.isRecording()) {
|
|
GLSMHooks.pendingProgramSelection = this;
|
|
return;
|
|
}
|
|
clipRebindPending = false;
|
|
final Pass pass = current;
|
|
if (pass == null) return;
|
|
final Program live = pass.liveProgram;
|
|
if (live != null && GLSMPrograms.getActiveProgram() == live.getProgramId() && pass.select(activeInstancing, GLSMRasterizer.clipEmulationActive()) != live) {
|
|
pass.rebindProgram();
|
|
}
|
|
}
|
|
|
|
private void clearPendingSelection() {
|
|
if (GLSMHooks.pendingProgramSelection == this) {
|
|
GLSMHooks.pendingProgramSelection = null;
|
|
}
|
|
}
|
|
|
|
private void matchPass() {
|
|
clearPendingSelection();
|
|
|
|
if (shouldOverrideShaders()) {
|
|
matchPass(getCondition(getPhase()));
|
|
}
|
|
resolveClipRebind();
|
|
}
|
|
|
|
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);
|
|
|
|
private static final InputAvailability LINE_INPUTS = InputAvailability.NONE;
|
|
|
|
@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(DeferredWorldRenderingPipeline::beginPassNow, this, 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 (GLSMPrograms.getActiveProgram() == 0) {
|
|
matchPass();
|
|
}
|
|
return;
|
|
}
|
|
final Program program = pass.select(Instancing.NONE, GLSMRasterizer.clipEmulationActive());
|
|
final GlFramebuffer expected = isBeforeTranslucent ? pass.framebufferBeforeTranslucents : pass.framebufferAfterTranslucents;
|
|
if (program != null && GLSMPrograms.getActiveProgram() == program.getProgramId() && GLSMFramebuffer.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<PatchShaderType, String> 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<SharedProgramKey, BuiltProgram> builtPrograms) {
|
|
// Use pre-computed transform if available, otherwise transform synchronously
|
|
Pair<String, InputAvailability> key = Pair.of(source.getName(), availability);
|
|
Map<PatchShaderType, String> 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.setVariantSource(source, id, 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.setVariantSource(source, id, 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<ImmutableSet<Integer>> 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<BufferBlendOverride> 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<ImmutableSet<Integer>> 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<ProgramSource> getDHTerrainShader() {
|
|
return resolver.resolve(ProgramId.DhTerrain);
|
|
}
|
|
|
|
public Optional<ProgramSource> getDHGenericShader() {
|
|
return resolver.resolve(ProgramId.DhGeneric);
|
|
}
|
|
|
|
public Optional<ProgramSource> getDHWaterShader() {
|
|
return resolver.resolve(ProgramId.DhWater);
|
|
}
|
|
|
|
public Optional<ProgramSource> 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<Integer> getFlippedBeforeShadow() {
|
|
return parityState.resolve(flippedBeforeShadow);
|
|
}
|
|
|
|
public ImmutableSet<Integer> getFlippedAfterPrepare() {
|
|
return parityState.resolve(flippedAfterPrepare);
|
|
}
|
|
|
|
public ImmutableSet<Integer> 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<BufferBlendOverride> bufferBlendOverrides;
|
|
private final boolean shadowViewport;
|
|
|
|
private ProgramSource variantSource;
|
|
private ProgramId variantId;
|
|
private InputAvailability variantAvailability;
|
|
private boolean variantShadow;
|
|
private final Program[][] variants = new Program[Instancing.VALUES.length][2];
|
|
private final boolean[][] variantAttempted = new boolean[Instancing.VALUES.length][2];
|
|
@Nullable
|
|
private Program boundProgram;
|
|
@Nullable
|
|
private Program liveProgram;
|
|
private final WideLineProgram[] wideLineVariants = new WideLineProgram[2];
|
|
private final boolean[] wideLineProgramAttempted = new boolean[2];
|
|
|
|
private Pass(@Nullable Program program, GlFramebuffer framebufferBeforeTranslucents, GlFramebuffer framebufferAfterTranslucents,
|
|
@Nullable AlphaTestOverride alphaTestOverride, @Nullable BlendModeOverride blendModeOverride, @Nullable List<BufferBlendOverride> bufferBlendOverrides, boolean shadowViewport) {
|
|
this.program = program;
|
|
this.variants[Instancing.NONE.ordinal()][0] = program;
|
|
this.variantAttempted[Instancing.NONE.ordinal()][0] = true;
|
|
this.framebufferBeforeTranslucents = framebufferBeforeTranslucents;
|
|
this.framebufferAfterTranslucents = framebufferAfterTranslucents;
|
|
this.alphaTestOverride = alphaTestOverride;
|
|
this.blendModeOverride = blendModeOverride;
|
|
this.bufferBlendOverrides = bufferBlendOverrides;
|
|
this.shadowViewport = shadowViewport;
|
|
}
|
|
|
|
public void use() {
|
|
IrisDisplayListState.runProgramTransition(Pass::useNow, this);
|
|
}
|
|
|
|
void rebindProgram() {
|
|
final boolean suspended = GLStateManager.suspendExitCapture();
|
|
try {
|
|
bindSelected();
|
|
} finally {
|
|
GLStateManager.resumeExitCapture(suspended);
|
|
}
|
|
}
|
|
|
|
void pushCustomUniforms() {
|
|
DeferredWorldRenderingPipeline.this.customUniforms.push(liveProgram == program ? this : liveProgram);
|
|
}
|
|
|
|
private void bindSelected() {
|
|
final Program selected = select(activeInstancing, GLSMRasterizer.clipEmulationActive());
|
|
liveProgram = selected;
|
|
if (activeInstancing == Instancing.NONE) boundProgram = selected;
|
|
if (selected != null) selected.use();
|
|
DeferredWorldRenderingPipeline.this.customUniforms.push(selected == null || selected == program ? this : selected);
|
|
}
|
|
|
|
private void useNow() {
|
|
final boolean suspended = GLStateManager.suspendExitCapture();
|
|
try {
|
|
applyState();
|
|
} finally {
|
|
GLStateManager.resumeExitCapture(suspended);
|
|
}
|
|
}
|
|
|
|
private void applyState() {
|
|
DepthColorStorage.unlockDepthColor();
|
|
|
|
if (isBeforeTranslucent) {
|
|
framebufferBeforeTranslucents.bind();
|
|
} else {
|
|
framebufferAfterTranslucents.bind();
|
|
}
|
|
|
|
if (shadowViewport) {
|
|
GLSMRasterizer.glViewport(0, 0, shadowMapResolution, shadowMapResolution);
|
|
} else {
|
|
final Framebuffer main = Minecraft.getMinecraft().getFramebuffer();
|
|
GLSMRasterizer.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);
|
|
}
|
|
|
|
bindSelected();
|
|
}
|
|
|
|
public void stopUsing() {
|
|
final boolean suspended = GLStateManager.suspendExitCapture();
|
|
try {
|
|
DepthColorStorage.unlockDepthColor();
|
|
|
|
if (alphaTestOverride != null) {
|
|
AlphaTestOverride.restore();
|
|
}
|
|
|
|
if (blendModeOverride != null || (bufferBlendOverrides != null && !bufferBlendOverrides.isEmpty())) {
|
|
BlendModeOverride.restore();
|
|
}
|
|
} finally {
|
|
GLStateManager.resumeExitCapture(suspended);
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
public Program getProgram() {
|
|
return program;
|
|
}
|
|
|
|
@Nullable
|
|
public Program boundProgram() {
|
|
return boundProgram != null ? boundProgram : program;
|
|
}
|
|
|
|
void setVariantSource(ProgramSource source, ProgramId id, InputAvailability availability, boolean shadow) {
|
|
this.variantSource = source;
|
|
this.variantId = id;
|
|
this.variantAvailability = availability;
|
|
this.variantShadow = shadow;
|
|
}
|
|
|
|
@Nullable
|
|
Program select(Instancing kind, boolean clipped) {
|
|
final int i = kind.ordinal();
|
|
if (!variantAttempted[i][0]) {
|
|
variantAttempted[i][0] = true;
|
|
if (variantSource != null && supportsInstancing[i]) {
|
|
variants[i][0] = sharedVariant(new InstancedVariantKey(variantSource.getName(), variantAvailability, variantShadow, kind, false),
|
|
() -> buildInstancedVariant(variantSource.getName(), variantAvailability, variantShadow, kind));
|
|
}
|
|
}
|
|
final Program unclipped = variants[i][0];
|
|
if (!clipped || unclipped == null) return unclipped;
|
|
if (!variantAttempted[i][1]) {
|
|
variantAttempted[i][1] = true;
|
|
variants[i][1] = sharedVariant(new InstancedVariantKey(variantSource.getName(), variantAvailability, variantShadow, kind, true),
|
|
() -> buildClipVariant(variantSource, variantId, variantAvailability, variantShadow, kind));
|
|
}
|
|
return variants[i][1] != null ? variants[i][1] : unclipped;
|
|
}
|
|
|
|
@Nullable
|
|
WideLineProgram wideLineProgram(boolean clipped) {
|
|
final int c = clipped ? 1 : 0;
|
|
if (!wideLineProgramAttempted[c]) {
|
|
wideLineProgramAttempted[c] = true;
|
|
if (variantSource != null && (!clipped || wideLineProgram(false) != null)) {
|
|
wideLineVariants[c] = sharedWideLineProgram(variantSource, variantAvailability, variantShadow, clipped);
|
|
}
|
|
}
|
|
return wideLineVariants[c] != null || !clipped ? wideLineVariants[c] : wideLineVariants[0];
|
|
}
|
|
|
|
public void destroy() {
|
|
if (this.program != null) {
|
|
this.program.destroy();
|
|
}
|
|
for (int i = 0; i < variants.length; i++) {
|
|
for (int c = 0; c < 2; c++) {
|
|
if ((i != Instancing.NONE.ordinal() || c != 0) && variants[i][c] != null) {
|
|
variants[i][c].destroy();
|
|
variants[i][c] = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private record InstancedVariantKey(String sourceName, InputAvailability availability, boolean shadow, Instancing kind, boolean clipped) {}
|
|
|
|
// Passes sharing a program also share its instanced variants
|
|
private final Map<InstancedVariantKey, Program> instancedVariantPrograms = new HashMap<>();
|
|
|
|
@Nullable
|
|
private Program sharedVariant(InstancedVariantKey key, Supplier<Program> build) {
|
|
if (instancedVariantPrograms.containsKey(key)) return instancedVariantPrograms.get(key);
|
|
final Program variant = build.get();
|
|
instancedVariantPrograms.put(key, variant);
|
|
return variant;
|
|
}
|
|
|
|
@Nullable
|
|
private Program buildClipVariant(ProgramSource source, ProgramId id, InputAvailability availability, boolean shadow, Instancing kind) {
|
|
final String name = source.getName() + kind.variantSuffix + "_clipped";
|
|
final boolean glint = GlintScrollInjector.shouldInject(id, source);
|
|
return buildClipped(source, name, (vertex, fragment) -> {
|
|
final Map<PatchShaderType, String> transformed = TransformPatcher.patchAttributesInstanced(vertex, null, null, null, fragment, availability, glint, kind, true);
|
|
return transformed != null ? linkVariant(name, transformed, availability, shadow) : null;
|
|
});
|
|
}
|
|
|
|
@Nullable
|
|
private static <T> T buildClipped(ProgramSource source, String name, BiFunction<String, String, T> build) {
|
|
if (source.getGeometrySource().isPresent() || source.getTessControlSource().isPresent() || source.getTessEvalSource().isPresent()) {
|
|
return null;
|
|
}
|
|
if (Tracy.ENABLED) Tracy.beginZone(Z_CLIP_VARIANT);
|
|
try {
|
|
return build.apply(source.getVertexSource().orElse(null), source.getFragmentSource().orElse(null));
|
|
} catch (Exception e) {
|
|
Iris.logger.warn("Clip plane variant failed for {}; clip planes stay unclipped there", name, e);
|
|
return null;
|
|
} finally {
|
|
if (Tracy.ENABLED) Tracy.endZone();
|
|
}
|
|
}
|
|
|
|
private Program linkVariant(String name, Map<PatchShaderType, String> transformed, InputAvailability availability, boolean shadow) {
|
|
final ProgramBuilder builder = beginBuilder(name, transformed);
|
|
wireGbufferProgram(builder, availability, shadow);
|
|
final Program variant = builder.build();
|
|
vertexWriteReplays.attach(name, variant, transformed, (samplers, images) -> wireGbufferResources(samplers, images, availability, shadow));
|
|
this.customUniforms.mapholderToPass(builder, variant);
|
|
return variant;
|
|
}
|
|
|
|
@Nullable
|
|
private Program buildInstancedVariant(String sourceName, InputAvailability availability, boolean shadow, Instancing kind) {
|
|
final Map<Pair<String, InputAvailability>, Map<PatchShaderType, String>> transforms = instancedAttributeTransforms.get(kind);
|
|
final Map<PatchShaderType, String> transformed = transforms != null ? transforms.get(Pair.of(sourceName, availability)) : null;
|
|
if (transformed == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
return linkVariant(sourceName + kind.variantSuffix, transformed, availability, shadow);
|
|
} 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()];
|
|
}
|
|
|
|
private boolean usesImages(@Nullable Program program) {
|
|
return program != null && (program.getActiveImages() > 0 || vertexWriteReplays.writesImages(program));
|
|
}
|
|
|
|
private boolean usesImage(@Nullable Program program, String image) {
|
|
return program != null && (GLSMPrograms.glGetUniformLocation(program.getProgramId(), image) != -1 || vertexWriteReplays.writesImage(program, image));
|
|
}
|
|
|
|
@Override
|
|
public boolean hasInstancedVariant(Instancing kind) {
|
|
return current != null && current.select(kind, false) != null;
|
|
}
|
|
|
|
public boolean hasInstancedVariant(RenderCondition condition, InputAvailability availability, Instancing kind) {
|
|
final Pass pass = table.match(condition, availability);
|
|
return pass != null && pass.select(kind, false) != null;
|
|
}
|
|
|
|
@Override
|
|
public void bindInstancedVariant(Instancing kind) {
|
|
activeInstancing = kind;
|
|
current.bindSelected();
|
|
}
|
|
|
|
private record WideLineProgram(Program program, int lineWidthLocation, int screenSizeLocation) {}
|
|
|
|
private record WideLineKey(String sourceName, InputAvailability availability, boolean shadow, boolean clipped) {}
|
|
|
|
@Nullable
|
|
private WideLineProgram sharedWideLineProgram(ProgramSource source, InputAvailability availability, boolean shadow, boolean clipped) {
|
|
final WideLineKey key = new WideLineKey(source.getName(), availability, shadow, clipped);
|
|
if (wideLinePrograms.containsKey(key)) return wideLinePrograms.get(key);
|
|
final WideLineProgram built = clipped ? buildClippedWideLineProgram(source, availability, shadow)
|
|
: buildWideLineProgram(source.getName() + "_widelines", wideLineTransforms.get(Pair.of(source.getName(), availability)), availability, shadow);
|
|
wideLinePrograms.put(key, built);
|
|
return built;
|
|
}
|
|
|
|
@Nullable
|
|
private WideLineProgram buildClippedWideLineProgram(ProgramSource source, InputAvailability availability, boolean shadow) {
|
|
final String name = source.getName() + "_widelines_clipped";
|
|
return buildClipped(source, name, (vertex, fragment) ->
|
|
buildWideLineProgram(name, TransformPatcher.patchAttributesWideLines(vertex, null, null, null, fragment, availability, true), availability, shadow));
|
|
}
|
|
|
|
@Nullable
|
|
private WideLineProgram buildWideLineProgram(String name, @Nullable Map<PatchShaderType, String> transformed, InputAvailability availability, boolean shadow) {
|
|
if (transformed == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
final Program program = linkVariant(name, transformed, availability, shadow);
|
|
final int id = program.getProgramId();
|
|
return new WideLineProgram(program, GLSMPrograms.glGetUniformLocation(id, "iris_LineWidth"), GLSMPrograms.glGetUniformLocation(id, "iris_ScreenSize"));
|
|
} catch (Exception e) {
|
|
Iris.logger.warn("Wide line program link failed for {}; lines there stay 1 px wide", name, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Nullable
|
|
private Pass passBeforeLines;
|
|
|
|
public boolean bindLineProgram() {
|
|
if (!shouldOverrideShaders() || DisplayListManager.isRecording()) {
|
|
return false;
|
|
}
|
|
GLSMHooks.resolvePendingProgram();
|
|
final Pass pass = current;
|
|
final Program bound = pass != null ? pass.boundProgram() : null;
|
|
if (bound == null || activeInstancing != Instancing.NONE || GLSMPrograms.getActiveProgram() != bound.getProgramId()) {
|
|
return false;
|
|
}
|
|
|
|
final boolean shadow = currentCondition == RenderCondition.SHADOW || currentCondition == RenderCondition.SHADOW_TRANSLUCENT;
|
|
final Pass linePass = shadow ? pass : table.match(RenderCondition.LINES, LINE_INPUTS);
|
|
if (linePass.getProgram() == null) {
|
|
return false;
|
|
}
|
|
final boolean needsWidening = shadow || !packWidensLines;
|
|
final WideLineProgram wide = needsWidening ? linePass.wideLineProgram(GLSMRasterizer.clipEmulationActive()) : null;
|
|
if (needsWidening && wide == null) {
|
|
return false;
|
|
}
|
|
|
|
passBeforeLines = pass;
|
|
if (linePass != pass) {
|
|
beginPass(linePass);
|
|
}
|
|
if (wide != null) {
|
|
wide.program().use();
|
|
this.customUniforms.push(wide.program());
|
|
final var viewport = GLSMRasterizer.getViewportState();
|
|
RenderSystem.uniform1f(wide.lineWidthLocation(), GLSMRasterizer.getLineState().getWidth());
|
|
RenderSystem.uniform2f(wide.screenSizeLocation(), viewport.width, viewport.height);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void restoreAfterLines() {
|
|
final Pass previous = passBeforeLines;
|
|
passBeforeLines = null;
|
|
if (previous == null) {
|
|
return;
|
|
}
|
|
if (current != previous) {
|
|
beginPass(previous);
|
|
} else {
|
|
previous.rebindProgram();
|
|
}
|
|
}
|
|
|
|
public void compileWideLinePrograms() {
|
|
table.match(RenderCondition.LINES, LINE_INPUTS).wideLineProgram(false);
|
|
final Pass shadowPass = table.match(RenderCondition.SHADOW, SHADOW_INPUTS);
|
|
if (shadowPass != null) shadowPass.wideLineProgram(false);
|
|
final Pass shadowWaterPass = table.match(RenderCondition.SHADOW_TRANSLUCENT, SHADOW_INPUTS);
|
|
if (shadowWaterPass != null) shadowWaterPass.wideLineProgram(false);
|
|
}
|
|
|
|
@Override
|
|
public void destroy() {
|
|
clearPendingSelection();
|
|
DepthColorStorage.unlockDepthColor();
|
|
BlendModeOverride.restore();
|
|
AlphaTestOverride.restore();
|
|
GLSMDepthStencilAlpha.enableAlphaTest();
|
|
GLSMDepthStencilAlpha.glAlphaFunc(GL11.GL_GREATER, 0.1f);
|
|
GLSMDepthStencilAlpha.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();
|
|
}
|
|
}
|
|
}
|
|
for (WideLineProgram wide : wideLinePrograms.values()) {
|
|
if (wide != null) wide.program().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<Pass> visited = new HashSet<>();
|
|
table.forEach(pass -> {
|
|
if (pass == null || !visited.add(pass)) return;
|
|
for (Instancing kind : Instancing.VALUES) {
|
|
if (kind != Instancing.NONE) pass.select(kind, false);
|
|
}
|
|
});
|
|
}
|
|
|
|
private static void destroyPasses(ProgramTable<Pass> table) {
|
|
Set<Pass> 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.
|
|
GLSMTextures.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();
|
|
GLSMFramebuffer.glClear(GL11.GL_DEPTH_BUFFER_BIT);
|
|
|
|
ImmutableList<ClearPass> 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<ClearPass> passes;
|
|
|
|
if (renderTargets.isFullClearRequired()) {
|
|
renderTargets.onFullClear();
|
|
parityState.reset();
|
|
passes = clearPassesFull;
|
|
} else {
|
|
passes = clearPasses;
|
|
}
|
|
|
|
final Vector3d fogColor3 = GLSMFog.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<String> 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<ImmutableSet<Integer>> 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 = GLSMPrograms.glGetUniformLocation(id, "iris_ModelViewMatrix");
|
|
final int normal = GLSMPrograms.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<ImmutableSet<Integer>> 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<CompletableFuture<String>> 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<String> 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<Integer> empty = ImmutableSet.of();
|
|
Supplier<ImmutableSet<Integer>> 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();
|
|
}
|
|
|
|
GLSMBlend.enableBlend();
|
|
GLSMDepthStencilAlpha.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<String> 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;
|
|
}
|
|
|
|
updatePbrSamplers(TextureFormatLoader.getFormat(), SodiumGameOptions.resolvedAnisotropicFiltering());
|
|
|
|
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");
|
|
GLSMEnable.glDisable(GL11.GL_TEXTURE_2D);
|
|
GLSMDepthStencilAlpha.glDepthMask(false);
|
|
|
|
final Vector3d fogColor = GLSMFog.getFogColor();
|
|
GLSMCurrentAttribs.glColor4f((float) fogColor.x, (float) fogColor.y, (float) fogColor.z, 1.0F);
|
|
|
|
horizonRenderer.renderHorizon(RenderingState.INSTANCE.getModelViewBuffer());
|
|
|
|
GLSMDepthStencilAlpha.glDepthMask(true);
|
|
GLSMEnable.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;
|
|
}
|
|
|
|
void updatePbrSamplers(TextureFormat format, int anisotropy) {
|
|
final boolean breaksAnisotropy = BlockRenderingSettings.INSTANCE.breaksAnisotropy();
|
|
if (samplerFormat == format && samplerAnisotropy == anisotropy && samplerBreaksAnisotropy == breaksAnisotropy) {
|
|
return;
|
|
}
|
|
normalSampler = IrisSamplers.getPbrSampler(format, PBRType.NORMAL, anisotropy);
|
|
specularSampler = IrisSamplers.getPbrSampler(format, PBRType.SPECULAR, anisotropy);
|
|
samplerFormat = format;
|
|
samplerAnisotropy = anisotropy;
|
|
samplerBreaksAnisotropy = breaksAnisotropy;
|
|
}
|
|
|
|
@Override
|
|
public void onBindTexture(int id) {
|
|
if (shouldBindPBR && isRenderingWorld) {
|
|
final boolean suspended = GLStateManager.suspendExitCapture();
|
|
try {
|
|
updatePbrTextures(id);
|
|
} finally {
|
|
GLStateManager.resumeExitCapture(suspended);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updatePbrTextures(int id) {
|
|
final PBRTextureHolder pbrHolder = PBRTextureManager.INSTANCE.getOrLoadHolder(id);
|
|
currentNormalTexture = pbrHolder.getNormalTexture().getGlTextureId();
|
|
currentSpecularTexture = pbrHolder.getSpecularTexture().getGlTextureId();
|
|
|
|
BatchStateGuard.suspend();
|
|
try {
|
|
PBRTextureManager.notifyPBRTexturesChanged();
|
|
} finally {
|
|
BatchStateGuard.resume();
|
|
}
|
|
}
|
|
|
|
private static CompletableFuture<Map<PatchShaderType, String>> submitCompositeTransform(ProgramSource source, TextureStage stage,
|
|
Object2ObjectMap<Tri<String, TextureType, TextureStage>, 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<Integer, CompletableFuture<Map<PatchShaderType, String>>> submitCompositeTransforms(ProgramSource[] sources,
|
|
TextureStage stage, Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap) {
|
|
// Count valid sources for initial capacity
|
|
int count = 0;
|
|
for (ProgramSource source : sources) {
|
|
if (source != null && source.isValid()) count++;
|
|
}
|
|
final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> 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<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>>
|
|
submitAttributeTransforms(ProgramFallbackResolver resolver, ProgramId[] ids, Instancing instancing, Map<String, Boolean> mvBuiltinsMemo) {
|
|
if (instancing == Instancing.CUBE && !AngelicaConfig.cubeInstancingEnabled()) {
|
|
return Collections.emptyMap();
|
|
}
|
|
final boolean instanced = instancing != Instancing.NONE;
|
|
final boolean matrixInstanced = instancing.hasInstanceHead();
|
|
final Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> futures = new HashMap<>();
|
|
final Set<String> 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 Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>>
|
|
submitWideLineTransforms(ProgramFallbackResolver resolver, boolean packWidensLines) {
|
|
final Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> futures = new HashMap<>();
|
|
if (!packWidensLines) {
|
|
submitWideLineTransform(futures, resolver.resolveNullable(ProgramId.Line), LINE_INPUTS);
|
|
}
|
|
submitWideLineTransform(futures, resolver.resolveNullable(ProgramId.Shadow), SHADOW_INPUTS);
|
|
submitWideLineTransform(futures, resolver.resolveNullable(ProgramId.ShadowWater), SHADOW_INPUTS);
|
|
return futures;
|
|
}
|
|
|
|
private static void submitWideLineTransform(Map<Pair<String, InputAvailability>, CompletableFuture<Map<PatchShaderType, String>>> futures,
|
|
@Nullable ProgramSource source, InputAvailability inputs) {
|
|
if (source == null || futures.containsKey(Pair.of(source.getName(), inputs))) {
|
|
return;
|
|
}
|
|
futures.put(Pair.of(source.getName(), inputs), Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchAttributesWideLines(
|
|
source.getVertexSource().orElse(null),
|
|
source.getGeometrySource().orElse(null),
|
|
source.getTessControlSource().orElse(null),
|
|
source.getTessEvalSource().orElse(null),
|
|
source.getFragmentSource().orElse(null),
|
|
inputs, false)));
|
|
}
|
|
|
|
private static final ProgramId[] INSTANCED_PROGRAM_IDS = {
|
|
ProgramId.Block, ProgramId.BlockTrans, ProgramId.Entities, ProgramId.EntitiesTrans,
|
|
ProgramId.Shadow, ProgramId.ShadowWater, ProgramId.ArmorGlint, ProgramId.SpiderEyes
|
|
};
|
|
|
|
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",
|
|
"modelViewMatrix", "modelViewMatrixInverse", "normalMatrix"
|
|
};
|
|
|
|
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<Map<PatchShaderType, String>> submitCeleritasTerrainTransform(ProgramSource source) {
|
|
return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchCeleritasTerrain(source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getFragmentSource().orElse(null)));
|
|
}
|
|
|
|
private static Int2ObjectArrayMap<CompletableFuture<String>> submitSetupComputeTransforms(ComputeSource[] compute,
|
|
Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap) {
|
|
if (compute == null) return new Int2ObjectArrayMap<>(0);
|
|
final Int2ObjectArrayMap<CompletableFuture<String>> 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 <T> Optional<T> first(Optional<T>... candidates) {
|
|
for (Optional<T> candidate : candidates) {
|
|
if (candidate.isPresent()) {
|
|
return candidate;
|
|
}
|
|
}
|
|
return Optional.empty();
|
|
}
|
|
|
|
public static void warmupTransforms(ProgramSet programs) {
|
|
final Object2ObjectMap<Tri<String, TextureType, TextureStage>, 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<String, Boolean> mvBuiltinsMemo = new ConcurrentHashMap<>();
|
|
for (Instancing kind : Instancing.VALUES) {
|
|
submitAttributeTransforms(resolver, attributeProgramIds(kind), kind, mvBuiltinsMemo);
|
|
}
|
|
|
|
final Optional<ProgramSource> terrainSource = first(programs.getGbuffersTerrain(), programs.getGbuffersTexturedLit(), programs.getGbuffersTextured(), programs.getGbuffersBasic());
|
|
final Optional<ProgramSource> translucentSource = first(programs.getGbuffersWater(), terrainSource);
|
|
final Optional<ProgramSource> shadowSource = programs.getShadow();
|
|
final Optional<ProgramSource> 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));
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|