generated from MrSphay/codex-agent-repository-kit
264 lines
9.0 KiB
Java
264 lines
9.0 KiB
Java
/*
|
|
* 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.minecraftforge.api.distmarker.Dist;
|
|
import net.minecraftforge.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;
|
|
|
|
}
|
|
}
|
|
|