Scaffold NeoForge port

src/main/java/com/vinlanx/explosionoverhaul/client/Blur.java

@@ -0,0 +1,262 @@
+/*
+ * Decompiled with CFR 0.152.
+ */
+package com.vinlanx.explosionoverhaul.client;
+
+import com.mojang.blaze3d.pipeline.RenderTarget;
+import com.mojang.blaze3d.pipeline.TextureTarget;
+import com.mojang.blaze3d.shaders.Uniform;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.BufferUploader;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import com.vinlanx.explosionoverhaul.client.ConcussionAudioEffect;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.ShaderInstance;
+import net.minecraft.util.Mth;
+import net.neoforged.api.distmarker.Dist;
+import net.neoforged.api.distmarker.OnlyIn;
+
+@OnlyIn(value=Dist.CLIENT)
+public class Blur {
+    private static final int FADE_IN_TICKS = 40;
+    private static final int FADE_OUT_TICKS = 100;
+    private static Phase phase = Phase.IDLE;
+    private static int holdTicks = 0;
+    private static int ticksInPhase = 0;
+    private static ShaderInstance shader;
+    private static RenderTarget blurTarget;
+    private static int lastWidth;
+    private static int lastHeight;
+    private static float currentIntensity;
+    private static float targetIntensity;
+    private static float currentDesaturation;
+    public static boolean APPLY_TO_HUD;
+    public static boolean APPLY_TO_HAND;
+
+    public static boolean isActive() {
+        return phase != Phase.IDLE;
+    }
+
+    public static float getCurrentIntensity() {
+        return currentIntensity;
+    }
+
+    public static void setShader(ShaderInstance instance) {
+        shader = instance;
+    }
+
+    public static void setDesaturation(float v) {
+        currentDesaturation = Mth.m_14036_((float)v, (float)0.0f, (float)1.0f);
+    }
+
+    public static void start(int seconds) {
+        Blur.start(seconds, 1.0f);
+    }
+
+    public static void start(int seconds, float intensity) {
+        int newHoldTicks = Mth.m_14045_((int)seconds, (int)1, (int)100) * 20;
+        float newIntensity = Mth.m_14036_((float)intensity, (float)0.0f, (float)1.0f);
+        if (phase != Phase.IDLE) {
+            targetIntensity = Mth.m_14036_((float)(targetIntensity + newIntensity), (float)0.0f, (float)1.0f);
+            holdTicks = Math.min(2000, holdTicks + newHoldTicks);
+            if (phase == Phase.FADE_OUT) {
+                phase = Phase.HOLD;
+                ticksInPhase = 0;
+            }
+        } else {
+            holdTicks = newHoldTicks;
+            ticksInPhase = 0;
+            targetIntensity = newIntensity;
+            phase = Phase.FADE_IN;
+            currentIntensity = 0.0f;
+        }
+    }
+
+    public static void stop() {
+        phase = Phase.IDLE;
+        ticksInPhase = 0;
+        holdTicks = 0;
+        currentIntensity = 0.0f;
+        targetIntensity = 0.0f;
+    }
+
+    public static void onClientTick() {
+        float intensity;
+        Minecraft mc = Minecraft.m_91087_();
+        if (mc.m_91104_() || phase == Phase.IDLE) {
+            return;
+        }
+        ++ticksInPhase;
+        switch (phase) {
+            case FADE_IN: {
+                float t = Math.min(1.0f, (float)ticksInPhase / 40.0f);
+                intensity = Blur.easeOutCubic(t) * targetIntensity;
+                if (ticksInPhase < 40) break;
+                phase = Phase.HOLD;
+                ticksInPhase = 0;
+                break;
+            }
+            case HOLD: {
+                intensity = targetIntensity;
+                if (ticksInPhase < holdTicks) break;
+                phase = Phase.FADE_OUT;
+                ticksInPhase = 0;
+                break;
+            }
+            case FADE_OUT: {
+                float t = Math.min(1.0f, (float)ticksInPhase / 100.0f);
+                intensity = targetIntensity * (1.0f - Blur.easeInCubic(t));
+                if (ticksInPhase < 100) break;
+                currentIntensity = 0.0f;
+                Blur.stop();
+                return;
+            }
+            default: {
+                intensity = 0.0f;
+            }
+        }
+        currentIntensity = intensity;
+        if (mc.f_91074_ != null) {
+            ConcussionAudioEffect.updateHeartbeat(mc.f_91074_, currentIntensity);
+        }
+    }
+
+    public static void render(RenderStage stage) {
+        if (phase == Phase.IDLE || shader == null) {
+            return;
+        }
+        if (!Blur.shouldRenderStage(stage)) {
+            return;
+        }
+        Minecraft mc = Minecraft.m_91087_();
+        if (mc == null) {
+            return;
+        }
+        RenderTarget mainTarget = mc.m_91385_();
+        if (mainTarget == null) {
+            return;
+        }
+        Blur.ensureTarget(mainTarget.f_83915_, mainTarget.f_83916_);
+        if (blurTarget == null) {
+            return;
+        }
+        RenderSystem.disableDepthTest();
+        RenderSystem.depthMask((boolean)false);
+        RenderSystem.disableBlend();
+        RenderSystem.setShaderColor((float)1.0f, (float)1.0f, (float)1.0f, (float)1.0f);
+        blurTarget.m_83947_(true);
+        RenderSystem.viewport((int)0, (int)0, (int)Blur.blurTarget.f_83915_, (int)Blur.blurTarget.f_83916_);
+        Blur.renderFullscreen(mainTarget.m_83975_(), currentIntensity, mainTarget.f_83915_, mainTarget.f_83916_);
+        mainTarget.m_83947_(true);
+        RenderSystem.viewport((int)0, (int)0, (int)mainTarget.f_83915_, (int)mainTarget.f_83916_);
+        Blur.renderFullscreen(blurTarget.m_83975_(), 0.0f, mainTarget.f_83915_, mainTarget.f_83916_);
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.depthMask((boolean)true);
+        RenderSystem.enableDepthTest();
+    }
+
+    private static boolean shouldRenderStage(RenderStage stage) {
+        if (APPLY_TO_HUD) {
+            return stage == RenderStage.HUD;
+        }
+        if (APPLY_TO_HAND && Blur.isFirstPerson()) {
+            return stage == RenderStage.HAND;
+        }
+        return stage == RenderStage.WORLD;
+    }
+
+    private static boolean isFirstPerson() {
+        Minecraft mc = Minecraft.m_91087_();
+        if (mc == null) {
+            return false;
+        }
+        return mc.f_91066_.m_92176_().m_90612_();
+    }
+
+    private static void ensureTarget(int width, int height) {
+        if (blurTarget == null || width != lastWidth || height != lastHeight) {
+            if (blurTarget != null) {
+                blurTarget.m_83930_();
+            }
+            blurTarget = new TextureTarget(width, height, false, Minecraft.f_91002_);
+            lastWidth = width;
+            lastHeight = height;
+        }
+    }
+
+    private static void renderFullscreen(int textureId, float intensity, int width, int height) {
+        Uniform desatUniform;
+        Uniform vignetteUniform;
+        Uniform heartbeatUniform;
+        Uniform outSizeUniform;
+        Uniform inSizeUniform;
+        RenderSystem.setShader(() -> shader);
+        RenderSystem.setShaderTexture((int)0, (int)textureId);
+        shader.m_173350_("DiffuseSampler", (Object)textureId);
+        float clamped = Mth.m_14036_((float)intensity, (float)0.0f, (float)1.0f);
+        Uniform intensityUniform = shader.m_173348_("Intensity");
+        if (intensityUniform != null) {
+            intensityUniform.m_5985_(clamped);
+        }
+        if ((inSizeUniform = shader.m_173348_("InSize")) != null) {
+            inSizeUniform.m_7971_((float)width, (float)height);
+        }
+        if ((outSizeUniform = shader.m_173348_("OutSize")) != null) {
+            outSizeUniform.m_7971_((float)width, (float)height);
+        }
+        if ((heartbeatUniform = shader.m_173348_("Heartbeat")) != null) {
+            heartbeatUniform.m_5985_(ConcussionAudioEffect.getCurrentHeartbeatVisual());
+        }
+        if ((vignetteUniform = shader.m_173348_("Vignette")) != null) {
+            vignetteUniform.m_5985_(1.0E-5f);
+        }
+        if ((desatUniform = shader.m_173348_("Desaturation")) != null) {
+            desatUniform.m_5985_(clamped);
+        }
+        BufferBuilder builder = Tesselator.m_85913_().m_85915_();
+        builder.m_166779_(VertexFormat.Mode.QUADS, DefaultVertexFormat.f_85817_);
+        builder.m_5483_(-1.0, -1.0, 0.0).m_7421_(0.0f, 1.0f).m_5752_();
+        builder.m_5483_(1.0, -1.0, 0.0).m_7421_(1.0f, 1.0f).m_5752_();
+        builder.m_5483_(1.0, 1.0, 0.0).m_7421_(1.0f, 0.0f).m_5752_();
+        builder.m_5483_(-1.0, 1.0, 0.0).m_7421_(0.0f, 0.0f).m_5752_();
+        BufferUploader.m_231202_((BufferBuilder.RenderedBuffer)builder.m_231175_());
+    }
+
+    private static float easeOutCubic(float t) {
+        float inv = 1.0f - t;
+        return 1.0f - inv * inv * inv;
+    }
+
+    private static float easeInCubic(float t) {
+        return t * t * t;
+    }
+
+    static {
+        lastWidth = -1;
+        lastHeight = -1;
+        currentIntensity = 0.0f;
+        targetIntensity = 1.0f;
+        currentDesaturation = 0.0f;
+        APPLY_TO_HUD = false;
+        APPLY_TO_HAND = true;
+    }
+
+    private static enum Phase {
+        IDLE,
+        FADE_IN,
+        HOLD,
+        FADE_OUT;
+
+    }
+
+    public static enum RenderStage {
+        WORLD,
+        HAND,
+        HUD;
+
+    }
+}