1956 lines
69 KiB
Java
1956 lines
69 KiB
Java
package defpackage;
|
|
|
|
import com.mojang.blaze3d.PrimitiveTopology;
|
|
import com.mojang.blaze3d.vertex.BufferBuilder;
|
|
import com.mojang.blaze3d.vertex.DefaultVertexFormat;
|
|
import com.mojang.blaze3d.vertex.PoseStack;
|
|
import com.mojang.blaze3d.vertex.VertexConsumer;
|
|
import com.mojang.blaze3d.vertex.PoseStack.Pose;
|
|
import java.util.concurrent.ThreadLocalRandom;
|
|
import java.util.function.Supplier;
|
|
import net.fabricmc.fabric.api.client.rendering.v1.level.LevelRenderContext;
|
|
import net.minecraft.client.Camera;
|
|
import net.minecraft.client.multiplayer.ClientLevel;
|
|
import net.minecraft.client.renderer.SubmitNodeCollector;
|
|
import net.minecraft.core.BlockPos.MutableBlockPos;
|
|
import net.minecraft.core.Direction.Axis;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.world.level.biome.Biome;
|
|
import net.minecraft.world.level.biome.Biome.Precipitation;
|
|
import net.minecraft.world.level.block.state.BlockState;
|
|
import net.minecraft.world.level.levelgen.Heightmap.Types;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import net.minecraft.world.phys.shapes.VoxelShape;
|
|
import org.joml.Vector3fc;
|
|
|
|
@rn(name = "BetterRain", description = "Realistic rain with single droplets, splash rings and wet ground", category = rl.RENDER)
|
|
public final class tr extends rm {
|
|
private static final int MAX_DROPS = 9000;
|
|
private static final float DROP_AREA_FACTOR = 4.0F;
|
|
private static final float FALL_SPEED_BASE = 9.0F;
|
|
private static final float SPEED_JITTER_MIN = 0.82F;
|
|
private static final float SPEED_JITTER_MAX = 1.18F;
|
|
private static final float STREAK_TIME = 0.032F;
|
|
private static final float STREAK_WIDTH = 0.025F;
|
|
private static final float STREAK_MIN_ANGULAR_WIDTH = 0.002F;
|
|
private static final float STREAK_BODY_SPLIT = 0.45F;
|
|
private static final float STREAK_HEAD_ALPHA = 0.45F;
|
|
private static final float ALPHA_JITTER_MIN = 0.55F;
|
|
private static final float ALPHA_JITTER_MAX = 1.15F;
|
|
private static final double SPAWN_CEILING = 9.0;
|
|
private static final double SPAWN_CEILING_SPAN = 3.0;
|
|
private static final double SPAWN_FLOOR_MARGIN = 6.0;
|
|
private static final double RECYCLE_RADIUS_GAIN = 1.3;
|
|
private static final double NEAR_FADE_START = 0.35;
|
|
private static final double NEAR_FADE_END = 1.4;
|
|
private static final int SPAWN_ATTEMPTS = 3;
|
|
private static final float WIND_SPEED_MAX = 3.2F;
|
|
private static final float WIND_GUST_AMPLITUDE = 0.22F;
|
|
private static final double WIND_GUST_RATE = 0.55;
|
|
private static final double WIND_TURN_RATE = 0.035;
|
|
private static final int SPLASH_CAPACITY = 128;
|
|
private static final int SPLASH_SEGMENTS = 16;
|
|
private static final long SPLASH_LIFETIME_MS = 360L;
|
|
private static final float SPLASH_START_RADIUS = 0.05F;
|
|
private static final float SPLASH_END_RADIUS = 0.26F;
|
|
private static final float SPLASH_RING_WIDTH = 0.032F;
|
|
private static final float SPLASH_ALPHA = 0.5F;
|
|
private static final double SPLASH_MAX_DISTANCE = 16.0;
|
|
private static final int SPLASH_IMPACT_DIVISOR = 2;
|
|
private static final float SURFACE_LIFT = 0.012F;
|
|
private static final long SCAN_INTERVAL_MS = 700L;
|
|
private static final float FLUID_SURFACE_INSET = 0.12F;
|
|
private static final float WET_EDGE_FADE_START = 0.62F;
|
|
private static final float WET_WRAP = 1024.0F;
|
|
private static final float WET_RIPPLE_SCALE = 0.85F;
|
|
private static final float WETNESS_RISE_PER_SECOND = 0.22F;
|
|
private static final float WETNESS_DRY_PER_SECOND = 0.08F;
|
|
private static final float WETNESS_MIN_VISIBLE = 0.02F;
|
|
private static final float RAIN_MIN_VISIBLE = 0.02F;
|
|
private static final int COVERAGE_PROBES = 12;
|
|
private static final float COVERAGE_RESPONSE_PER_SECOND = 1.5F;
|
|
private static final String STYLE_REFLECTIONS = "Reflections";
|
|
private static final String STYLE_DECALS = "Decals";
|
|
private static final String QUALITY_LOW = "Low";
|
|
private static final String QUALITY_MEDIUM = "Medium";
|
|
private static final String QUALITY_HIGH = "High";
|
|
private static final String QUALITY_ULTRA = "Ultra";
|
|
private static final float QUALITY_INDEX_LOW = 0.0F;
|
|
private static final float QUALITY_INDEX_MEDIUM = 1.0F;
|
|
private static final float QUALITY_INDEX_HIGH = 2.0F;
|
|
private static final float QUALITY_INDEX_ULTRA = 3.0F;
|
|
private static final float REFLECTION_DARKENING_SCALE = 0.4F;
|
|
private static final double MAX_FRAME_SECONDS = 0.1;
|
|
private static final long TIME_PERIOD_MS = 600000L;
|
|
private static final float MILLIS_PER_SECOND = 1000.0F;
|
|
private static final double TAU = Math.PI * 2;
|
|
private static final float BEHIND_CAMERA_DOT = -0.35F;
|
|
private static final double BEHIND_CAMERA_MIN_DISTANCE = 3.0;
|
|
private final sm densitySetting = new sm("Density", 0.8F, 0.1F, 3.0F, 0.1F)
|
|
.description(
|
|
"How many droplets fall around you"
|
|
);
|
|
private final sm speedSetting = new sm(
|
|
"Fall speed", 1.0F, 0.4F, 2.0F, 0.05F
|
|
)
|
|
.description("How fast the droplets fall");
|
|
private final sm sizeSetting = new sm("Drop size", 1.0F, 0.5F, 2.5F, 0.1F)
|
|
.description(
|
|
"Length and width of a single droplet"
|
|
);
|
|
private final sm radiusSetting = new sm("Radius", 16.0F, 8.0F, 32.0F, 1.0F)
|
|
.description(
|
|
"Distance around you the droplets spawn in"
|
|
);
|
|
private final sm windSetting = new sm("Wind", 0.2F, 0.0F, 1.0F, 0.05F)
|
|
.description("Sideways drift of the droplets");
|
|
private final sm opacitySetting = new sm("Opacity", 0.5F, 0.1F, 1.0F, 0.05F)
|
|
.description("Transparency of the droplets");
|
|
private final ru splashSetting = new ru(
|
|
"Splashes",
|
|
(boolean)((((-1654652688 ^ 1654652689) + ((-1654652688 & 1654652689) << 1))
|
|
) != 0))
|
|
.description(
|
|
"Expanding rings where droplets hit a surface"
|
|
);
|
|
private final ru wetSetting = new ru(
|
|
"Wet ground",
|
|
(boolean)((((-1998857488 ^ 1998857489) + ((-1998857488 & 1998857489) << 1))
|
|
) != 0))
|
|
.description(
|
|
"Makes surfaces look soaked while it rains"
|
|
);
|
|
private final sg wetStyleSetting;
|
|
private final sm wetStrengthSetting;
|
|
private final sg reflectionQualitySetting;
|
|
private final sm reflectionStrengthSetting;
|
|
private final ru surfaceRippleSetting;
|
|
private final sm rippleSpeedSetting;
|
|
private final sm wetRadiusSetting;
|
|
private final ru hideVanillaSetting;
|
|
private final ru hideVanillaSplashSetting;
|
|
private final rx tintSetting;
|
|
private final double[] dropX;
|
|
private final double[] dropY;
|
|
private final double[] dropZ;
|
|
private final float[] dropSpeed;
|
|
private final float[] dropAlpha;
|
|
private final float[] dropGround;
|
|
private final int[] dropColumnX;
|
|
private final int[] dropColumnZ;
|
|
private int dropCount;
|
|
private final double[] splashX;
|
|
private final double[] splashY;
|
|
private final double[] splashZ;
|
|
private final long[] splashStart;
|
|
private int splashHead;
|
|
private int splashSize;
|
|
private int impactCounter;
|
|
private int[] columnX;
|
|
private int[] columnZ;
|
|
private float[] columnY;
|
|
private int columnCount;
|
|
private int scanBlockX;
|
|
private int scanBlockZ;
|
|
private int scanRadius;
|
|
private long scanTime;
|
|
private final MutableBlockPos scanPos;
|
|
private final MutableBlockPos precipitationPos;
|
|
private long lastFrameNanos;
|
|
private float wetness;
|
|
private float frameRainLevel;
|
|
private float rainCoverage;
|
|
private boolean coverageSampled;
|
|
private boolean frameActive;
|
|
private double windX;
|
|
private double windZ;
|
|
public static final tr INSTANCE = new tr();
|
|
|
|
private tr() {
|
|
String var10003 = "Wet style";
|
|
Supplier var10004 = () -> this.wetSetting.isEnabled();
|
|
String[] var10005 = new String[2];
|
|
var10005[0] = "Reflections";
|
|
var10005[1] = "Decals";
|
|
this.wetStyleSetting = new sg(var10003, var10004, var10005)
|
|
.describe(
|
|
"Reflections",
|
|
"Screen-space reflections on every wet surface"
|
|
)
|
|
.describe(
|
|
"Decals",
|
|
"Cheap glossy film with ripple rings on the ground"
|
|
)
|
|
.description(
|
|
"How the wet surfaces are rendered"
|
|
);
|
|
this.wetStrengthSetting = new sm(
|
|
"Wet strength",
|
|
0.75F,
|
|
0.1F,
|
|
1.0F,
|
|
0.05F,
|
|
() -> this.wetSetting.isEnabled()
|
|
)
|
|
.description(
|
|
"How wet and dark the surfaces look"
|
|
);
|
|
var10003 = "Reflection quality";
|
|
var10004 = () -> {
|
|
int var2x = 0;
|
|
int var1x = 1934149679;
|
|
|
|
while (true) {
|
|
switch (var1x) {
|
|
case -1706837372:
|
|
if (this.wetStyleSetting.is("Reflections")) {
|
|
var1x = 1672803991;
|
|
} else {
|
|
var1x = -474757413;
|
|
}
|
|
break;
|
|
case -935688700:
|
|
return Boolean.valueOf((boolean)((var2x) != 0));
|
|
case -474757413:
|
|
var2x = 0;
|
|
var1x = -935688700;
|
|
break;
|
|
case 1672803991:
|
|
var2x = 1;
|
|
var1x = -935688700;
|
|
break;
|
|
case 1934149679:
|
|
default:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1x = -1706837372;
|
|
} else {
|
|
var1x = -474757413;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var10005 = new String[4];
|
|
var10005[0] = "Low";
|
|
var10005[1] = "Medium";
|
|
var10005[2] = "High";
|
|
var10005[3] = "Ultra";
|
|
this.reflectionQualitySetting = new sg(var10003, var10004, var10005)
|
|
.describe(
|
|
"Low",
|
|
"Short rays, cheapest"
|
|
)
|
|
.describe(
|
|
"Medium",
|
|
"Balanced ray budget"
|
|
)
|
|
.describe(
|
|
"High",
|
|
"Long rays, sharper reflections"
|
|
)
|
|
.describe(
|
|
"Ultra",
|
|
"Longest rays, heaviest"
|
|
)
|
|
.description(
|
|
"Ray budget of the screen-space reflections"
|
|
);
|
|
this.reflectionStrengthSetting = new sm(
|
|
"Reflection strength", 0.75F, 0.1F, 1.5F, 0.05F, () -> {
|
|
int var2x = 0;
|
|
int var1x = 1059588498;
|
|
|
|
while (true) {
|
|
switch (var1x) {
|
|
case -944101552:
|
|
var2x = 0;
|
|
var1x = 2075424891;
|
|
break;
|
|
case -277490681:
|
|
if (this.wetStyleSetting.is("Reflections")) {
|
|
var1x = -138731655;
|
|
} else {
|
|
var1x = -944101552;
|
|
}
|
|
break;
|
|
case -138731655:
|
|
var2x = 1;
|
|
var1x = 2075424891;
|
|
break;
|
|
case 1059588498:
|
|
default:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1x = -277490681;
|
|
} else {
|
|
var1x = -944101552;
|
|
}
|
|
break;
|
|
case 2075424891:
|
|
return Boolean.valueOf((boolean)((var2x) != 0));
|
|
}
|
|
}
|
|
}
|
|
)
|
|
.description(
|
|
"How strongly surfaces mirror the world"
|
|
);
|
|
this.surfaceRippleSetting = new ru(
|
|
"Surface ripples",
|
|
(boolean)(((1)) != 0),
|
|
() -> {
|
|
int var2x = 0;
|
|
int var1x = -1917476373;
|
|
|
|
while (true) {
|
|
switch (var1x) {
|
|
case -1917476373:
|
|
default:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1x = 333651828;
|
|
} else {
|
|
var1x = -172407243;
|
|
}
|
|
break;
|
|
case -172407243:
|
|
var2x = 0;
|
|
var1x = 1610895243;
|
|
break;
|
|
case 333651828:
|
|
if (this.wetStyleSetting.is("Reflections")) {
|
|
var1x = 689869906;
|
|
} else {
|
|
var1x = -172407243;
|
|
}
|
|
break;
|
|
case 689869906:
|
|
var2x = 1;
|
|
var1x = 1610895243;
|
|
break;
|
|
case 1610895243:
|
|
return Boolean.valueOf((boolean)((var2x) != 0));
|
|
}
|
|
}
|
|
}
|
|
)
|
|
.description(
|
|
"Distorts the reflections with raindrop ripples"
|
|
);
|
|
this.rippleSpeedSetting = new sm(
|
|
"Ripple speed", 1.0F, 0.1F, 3.0F, 0.1F, () -> {
|
|
int var2x = 0;
|
|
int var1x = -1688329886;
|
|
|
|
while (true) {
|
|
switch (var1x) {
|
|
case -1688329886:
|
|
default:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1x = -1424158767;
|
|
} else {
|
|
var1x = 872909174;
|
|
}
|
|
break;
|
|
case -1424158767:
|
|
if (this.wetStyleSetting.is("Reflections")) {
|
|
var1x = -740928128;
|
|
} else {
|
|
var1x = 872909174;
|
|
}
|
|
break;
|
|
case -1223723211:
|
|
var2x = 1;
|
|
var1x = 1045803332;
|
|
break;
|
|
case -740928128:
|
|
if (this.surfaceRippleSetting.isEnabled()) {
|
|
var1x = -1223723211;
|
|
} else {
|
|
var1x = 872909174;
|
|
}
|
|
break;
|
|
case 872909174:
|
|
var2x = 0;
|
|
var1x = 1045803332;
|
|
break;
|
|
case 1045803332:
|
|
return Boolean.valueOf((boolean)((var2x) != 0));
|
|
}
|
|
}
|
|
}
|
|
)
|
|
.description("Speed of the reflected ripples");
|
|
this.wetRadiusSetting = new sm("Wet radius", 14.0F, 6.0F, 24.0F, 1.0F, () -> {
|
|
int var2x = 0;
|
|
int var1x = -2140843568;
|
|
|
|
while (true) {
|
|
switch (var1x) {
|
|
case -2140843568:
|
|
default:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1x = 869618676;
|
|
} else {
|
|
var1x = -1731635205;
|
|
}
|
|
break;
|
|
case -1731635205:
|
|
var2x = 0;
|
|
var1x = -1302965990;
|
|
break;
|
|
case -1302965990:
|
|
return Boolean.valueOf((boolean)((var2x) != 0));
|
|
case -280579523:
|
|
var2x = 1;
|
|
var1x = -1302965990;
|
|
break;
|
|
case 869618676:
|
|
if (this.wetStyleSetting.is("Decals")) {
|
|
var1x = -280579523;
|
|
} else {
|
|
var1x = -1731635205;
|
|
}
|
|
}
|
|
}
|
|
})
|
|
.description(
|
|
"Distance the wet film is drawn around you"
|
|
);
|
|
this.hideVanillaSetting = new ru(
|
|
"Hide vanilla rain",
|
|
(boolean)((((2031226006 | -2031226005) + (2031226006 & -2031226005))
|
|
) != 0))
|
|
.description(
|
|
"Replaces the vanilla rain sheets with the custom droplets"
|
|
);
|
|
this.hideVanillaSplashSetting = new ru(
|
|
"Hide vanilla splashes",
|
|
(boolean)((((-1939600197 | 1939600198) + (-1939600197 & 1939600198))
|
|
) != 0))
|
|
.description(
|
|
"Removes the blocky vanilla splash particles on the ground"
|
|
);
|
|
this.tintSetting = new rx(
|
|
"Tint",
|
|
new asu(
|
|
196,
|
|
214,
|
|
(32974235 | -32973997) + (32974235 & -32973997)
|
|
)
|
|
)
|
|
.description(
|
|
"Color of the droplets and the wet sheen"
|
|
);
|
|
this.dropX = new double[9000];
|
|
this.dropY = new double[9000];
|
|
this.dropZ = new double[9000];
|
|
this.dropSpeed = new float[9000];
|
|
this.dropAlpha = new float[9000];
|
|
this.dropGround = new float[9000];
|
|
this.dropColumnX = new int[9000];
|
|
this.dropColumnZ = new int[9000];
|
|
this.splashX = new double[128];
|
|
this.splashY = new double[128];
|
|
this.splashZ = new double[128];
|
|
this.splashStart = new long[128];
|
|
this.columnX = new int[0];
|
|
this.columnZ = new int[0];
|
|
this.columnY = new float[0];
|
|
this.scanBlockX = -2147483648;
|
|
this.scanBlockZ = -2147483648;
|
|
this.scanRadius = -1;
|
|
this.scanPos = new MutableBlockPos();
|
|
this.precipitationPos = new MutableBlockPos();
|
|
this.reflectionQualitySetting.set("Medium");
|
|
}
|
|
|
|
public boolean usesWetReflections() {
|
|
int var2 = 0;
|
|
int var1 = -919305186;
|
|
|
|
while (true) {
|
|
switch (var1) {
|
|
case -1607343285:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var1 = 160753762;
|
|
} else {
|
|
var1 = 2078338810;
|
|
}
|
|
break;
|
|
case -1467704790:
|
|
var2 = 1;
|
|
var1 = -1297070228;
|
|
break;
|
|
case -1368435891:
|
|
if (this.wetness > 0.02F) {
|
|
var1 = -1467704790;
|
|
} else {
|
|
var1 = 2078338810;
|
|
}
|
|
break;
|
|
case -1297070228:
|
|
return (boolean)((var2) != 0);
|
|
case -919305186:
|
|
default:
|
|
if (this.isEnabled()) {
|
|
var1 = -1607343285;
|
|
} else {
|
|
var1 = 2078338810;
|
|
}
|
|
break;
|
|
case 160753762:
|
|
if (this.wetStyleSetting.is("Reflections")) {
|
|
var1 = -1368435891;
|
|
} else {
|
|
var1 = 2078338810;
|
|
}
|
|
break;
|
|
case 2078338810:
|
|
var2 = 0;
|
|
var1 = -1297070228;
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean usesWetRipples() {
|
|
return this.surfaceRippleSetting.isEnabled();
|
|
}
|
|
|
|
public float reflectionStrength() {
|
|
return this.reflectionStrengthSetting.getCurrent();
|
|
}
|
|
|
|
public float wetDarkening() {
|
|
return this.wetStrengthSetting.getCurrent() * 0.4F;
|
|
}
|
|
|
|
public float wetAmount() {
|
|
return this.wetness;
|
|
}
|
|
|
|
public float rippleSpeed() {
|
|
return this.rippleSpeedSetting.getCurrent();
|
|
}
|
|
|
|
public float rainStrength() {
|
|
return this.localRainLevel();
|
|
}
|
|
|
|
private float localRainLevel() {
|
|
return this.frameRainLevel * this.rainCoverage;
|
|
}
|
|
|
|
public float reflectionQualityIndex() {
|
|
int var1 = 1552894445;
|
|
|
|
while (true) {
|
|
switch (var1) {
|
|
case -2094161462:
|
|
return 2.0F;
|
|
case -805298701:
|
|
return 1.0F;
|
|
case 30783600:
|
|
return 3.0F;
|
|
case 468550504:
|
|
if (this.reflectionQualitySetting.is("High")) {
|
|
var1 = -2094161462;
|
|
} else {
|
|
var1 = 899051105;
|
|
}
|
|
break;
|
|
case 899051105:
|
|
if (this.reflectionQualitySetting.is("Ultra")) {
|
|
var1 = 30783600;
|
|
} else {
|
|
var1 = -805298701;
|
|
}
|
|
break;
|
|
case 1232032631:
|
|
return 0.0F;
|
|
case 1552894445:
|
|
default:
|
|
if (this.reflectionQualitySetting.is("Low")) {
|
|
var1 = 1232032631;
|
|
} else {
|
|
var1 = 468550504;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onEnable() {
|
|
super.onEnable();
|
|
this.reset();
|
|
}
|
|
|
|
@Override
|
|
public void onDisable() {
|
|
super.onDisable();
|
|
this.reset();
|
|
this.releaseReflections();
|
|
}
|
|
|
|
private void releaseReflections() {
|
|
aus.release();
|
|
}
|
|
|
|
private void reset() {
|
|
this.dropCount = 0;
|
|
this.splashHead = 0;
|
|
this.splashSize = 0;
|
|
this.columnCount = 0;
|
|
this.scanRadius = -1;
|
|
this.scanBlockX = -2147483648;
|
|
this.scanBlockZ = -2147483648;
|
|
this.wetness = 0.0F;
|
|
this.rainCoverage = 0.0F;
|
|
this.coverageSampled = (boolean)(((0)) != 0);
|
|
this.lastFrameNanos = (-841315360934827612L ^ 841315360934827612L) + ((-841315360934827612L & 841315360934827612L) << 1);
|
|
}
|
|
|
|
public boolean hidesVanillaRain() {
|
|
int var2 = 0;
|
|
int var1 = 1533268410;
|
|
|
|
while (true) {
|
|
switch (var1) {
|
|
case -1980542863:
|
|
return (boolean)((var2) != 0);
|
|
case -1267613423:
|
|
var2 = 0;
|
|
var1 = -1980542863;
|
|
break;
|
|
case -347318595:
|
|
var2 = 1;
|
|
var1 = -1980542863;
|
|
break;
|
|
case 714019240:
|
|
if (this.hideVanillaSetting.isEnabled()) {
|
|
var1 = 1071409559;
|
|
} else {
|
|
var1 = -1267613423;
|
|
}
|
|
break;
|
|
case 1071409559:
|
|
if (this.frameActive) {
|
|
var1 = -347318595;
|
|
} else {
|
|
var1 = -1267613423;
|
|
}
|
|
break;
|
|
case 1533268410:
|
|
default:
|
|
if (this.isEnabled()) {
|
|
var1 = 714019240;
|
|
} else {
|
|
var1 = -1267613423;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean hidesVanillaSplashes() {
|
|
int var2 = 0;
|
|
int var1 = 582151046;
|
|
|
|
while (true) {
|
|
switch (var1) {
|
|
case -1528932800:
|
|
if (this.frameActive) {
|
|
var1 = 1485593109;
|
|
} else {
|
|
var1 = 165646648;
|
|
}
|
|
break;
|
|
case 165646648:
|
|
var2 = 0;
|
|
var1 = 1198838785;
|
|
break;
|
|
case 582151046:
|
|
default:
|
|
if (this.isEnabled()) {
|
|
var1 = 1385897110;
|
|
} else {
|
|
var1 = 165646648;
|
|
}
|
|
break;
|
|
case 1198838785:
|
|
return (boolean)((var2) != 0);
|
|
case 1385897110:
|
|
if (this.hideVanillaSplashSetting.isEnabled()) {
|
|
var1 = -1528932800;
|
|
} else {
|
|
var1 = 165646648;
|
|
}
|
|
break;
|
|
case 1485593109:
|
|
var2 = 1;
|
|
var1 = 1198838785;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onWorldRender(LevelRenderContext var1) {
|
|
this.frameActive = (boolean)(((0)) != 0);
|
|
if (this.isEnabled() && mc.player != null && mc.level != null) {
|
|
PoseStack var2 = var1.poseStack();
|
|
SubmitNodeCollector var3 = var1.submitNodeCollector();
|
|
Camera var4 = mc.getEntityRenderDispatcher().camera;
|
|
if (var2 != null && var3 != null && var4 != null) {
|
|
ClientLevel var5 = mc.level;
|
|
float var6 = mc.getDeltaTracker().getGameTimeDeltaPartialTick((boolean)((((-665987122 | 665987122) + (-665987122 & 665987122))) != 0));
|
|
this.frameRainLevel = this.rainStrength(var5, var6);
|
|
this.frameActive = (boolean)(((this.frameRainLevel > 0.02F
|
|
? 1: (-378159891 ^ 378159891) + ((-378159891 & 378159891) << 1))) != 0);
|
|
float var7 = this.frameDelta();
|
|
Vec3 var8 = var4.position();
|
|
this.updateCoverage(var5, var8, var7);
|
|
this.updateWetness(var7);
|
|
this.updateWind();
|
|
if (this.frameActive || this.dropCount != 0 || this.splashSize != 0) {
|
|
this.simulate(var5, var8, var7);
|
|
int var9 = this.tintSetting.getIntColor() & 16777215;
|
|
this.submitDroplets(var3, var2, var4, var8, var9);
|
|
this.submitSplashes(var3, var2, var4, var8, var9);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onWorldDraw(LevelRenderContext var1) {
|
|
Camera var2 = null;
|
|
atd var3 = null;
|
|
Vec3 var4 = null;
|
|
int var5 = 0;
|
|
float var6 = 0.0F;
|
|
BufferBuilder var7 = null;
|
|
int var8 = 397461930;
|
|
|
|
while (true) {
|
|
switch (var8) {
|
|
case -1310980301:
|
|
if (this.wetStyleSetting.is("Decals")) {
|
|
var8 = -708900059;
|
|
} else {
|
|
var8 = -567781745;
|
|
}
|
|
break;
|
|
case -708900059:
|
|
if (mc.level == null) {
|
|
var8 = -567781745;
|
|
} else {
|
|
var8 = 741274104;
|
|
}
|
|
break;
|
|
case -567781745:
|
|
return;
|
|
case -488901600:
|
|
var5 = this.tintSetting.getIntColor() & 16777215;
|
|
var6 = (float)(
|
|
System.currentTimeMillis() % ((1065960968164314735L ^ -1065960968163714735L) + ((1065960968164314735L & -1065960968163714735L) << 1))
|
|
)
|
|
/ 1000.0F;
|
|
var3.use();
|
|
var3.setResolution(mc.getWindow().getWidth(), mc.getWindow().getHeight());
|
|
var3.setTime(var6);
|
|
var3.setTintColor(
|
|
(var5 >> (-1693545370 ^ 1693545386) + ((-1693545370 & 1693545386) << 1) & (956208320 ^ -956208065) + ((956208320 & -956208065) << 1))
|
|
/ 255.0F,
|
|
(var5 >> (1674960648 ^ -1674960640) + ((1674960648 & -1674960640) << 1) & (1818893044 ^ -1818892789) + ((1818893044 & -1818892789) << 1))
|
|
/ 255.0F,
|
|
(var5 & (1601070161 | -1601069906) + (1601070161 & -1601069906)) / 255.0F
|
|
);
|
|
var3.setFade(this.wetness * this.wetStrengthSetting.getCurrent());
|
|
var3.setProgress(this.localRainLevel());
|
|
var3.setRange(0.85F);
|
|
var3.setCameraPos(wrapCoordinate(var4.x), (float)var4.y, wrapCoordinate(var4.z));
|
|
arj.setCurrentLayer(arj.positionColor());
|
|
var7 = arj.begin(PrimitiveTopology.QUADS, DefaultVertexFormat.POSITION_COLOR);
|
|
this.emitSurfaceQuads(var7, var2, var4);
|
|
arj.drawCurrent(var7);
|
|
return;
|
|
case 55864545:
|
|
if (this.wetSetting.isEnabled()) {
|
|
var8 = -1310980301;
|
|
} else {
|
|
var8 = -567781745;
|
|
}
|
|
break;
|
|
case 165271634:
|
|
var4 = var2.position();
|
|
this.rebuildSurfaceCache(mc.level, var4);
|
|
if (this.columnCount == 0) {
|
|
var8 = 437385542;
|
|
} else {
|
|
var8 = -488901600;
|
|
}
|
|
break;
|
|
case 254658301:
|
|
return;
|
|
case 397461930:
|
|
default:
|
|
if (this.isEnabled()) {
|
|
var8 = 55864545;
|
|
} else {
|
|
var8 = -567781745;
|
|
}
|
|
break;
|
|
case 437385542:
|
|
return;
|
|
case 741274104:
|
|
if (this.wetness <= 0.02F) {
|
|
var8 = 1952770734;
|
|
} else {
|
|
var8 = 1800211461;
|
|
}
|
|
break;
|
|
case 1800211461:
|
|
var2 = mc.getEntityRenderDispatcher().camera;
|
|
var3 = atb.worldWetGroundProgram;
|
|
if (var2 != null) {
|
|
var8 = 2022459050;
|
|
} else {
|
|
var8 = 254658301;
|
|
}
|
|
break;
|
|
case 1952770734:
|
|
return;
|
|
case 2022459050:
|
|
if (var3 == null) {
|
|
var8 = 254658301;
|
|
} else {
|
|
var8 = 165271634;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private float frameDelta() {
|
|
long var1 = (5115088920242951381L ^ -5115088920242951381L) + ((5115088920242951381L & -5115088920242951381L) << 1);
|
|
double var3 = 0.0;
|
|
int var5 = -753533109;
|
|
|
|
while (true) {
|
|
switch (var5) {
|
|
case -2026143777:
|
|
var3 = (var1 - this.lastFrameNanos) / 1.0E9;
|
|
this.lastFrameNanos = var1;
|
|
return (float)Math.min(var3, 0.1);
|
|
case -1431068620:
|
|
this.lastFrameNanos = var1;
|
|
return 0.0F;
|
|
case -753533109:
|
|
}
|
|
|
|
var1 = System.nanoTime();
|
|
if (this.lastFrameNanos == (8649758037746290463L | -8649758037746290463L) + (8649758037746290463L & -8649758037746290463L)) {
|
|
var5 = -1431068620;
|
|
} else {
|
|
var5 = -2026143777;
|
|
}
|
|
}
|
|
}
|
|
|
|
private float rainStrength(ClientLevel var1, float var2) {
|
|
float var3 = 0.0F;
|
|
int var4 = -1212127870;
|
|
|
|
while (true) {
|
|
switch (var4) {
|
|
case -1212127870:
|
|
default:
|
|
var3 = var1.getRainLevel(var2);
|
|
if (var3 <= 0.02F) {
|
|
var4 = -1165002161;
|
|
} else {
|
|
var4 = 1149890896;
|
|
}
|
|
break;
|
|
case -1165002161:
|
|
return 0.0F;
|
|
case 1149890896:
|
|
return Mth.clamp(var3, 0.0F, 1.0F);
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean isRainColumn(ClientLevel var1, int var2, int var3, float var4) {
|
|
Biome var5 = null;
|
|
int var7 = 0;
|
|
int var6 = -576227439;
|
|
|
|
while (true) {
|
|
switch (var6) {
|
|
case -2127938668:
|
|
var7 = 1;
|
|
var6 = -2072910498;
|
|
break;
|
|
case -2072910498:
|
|
return (boolean)((var7) != 0);
|
|
case -576227439:
|
|
default:
|
|
this.precipitationPos.set(var2, Mth.floor(var4), var3);
|
|
var5 = (Biome)var1.getBiome(this.precipitationPos).value();
|
|
if (var5.getPrecipitationAt(this.precipitationPos, var1.getSeaLevel()) == Precipitation.RAIN) {
|
|
var6 = -2127938668;
|
|
} else {
|
|
var6 = 1156466947;
|
|
}
|
|
break;
|
|
case 1156466947:
|
|
var7 = 0;
|
|
var6 = -2072910498;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateCoverage(ClientLevel var1, Vec3 var2, float var3) {
|
|
if (this.frameActive) {
|
|
float var4 = this.radiusSetting.getCurrent();
|
|
ThreadLocalRandom var5 = ThreadLocalRandom.current();
|
|
int var6 = 0;
|
|
|
|
for (int var7 = 0; var7 < 12; var7++) {
|
|
double var8 = var5.nextDouble() * (Math.PI * 2);
|
|
double var10 = var4 * Math.sqrt(var5.nextDouble());
|
|
int var12 = Mth.floor(var2.x + Math.cos(var8) * var10);
|
|
int var13 = Mth.floor(var2.z + Math.sin(var8) * var10);
|
|
float var14 = var1.getHeight(Types.MOTION_BLOCKING, var12, var13);
|
|
if (this.isRainColumn(var1, var12, var13, var14)) {
|
|
var6++;
|
|
}
|
|
}
|
|
|
|
float var15 = var6 / 12.0F;
|
|
if (!this.coverageSampled) {
|
|
this.rainCoverage = var15;
|
|
this.coverageSampled = (boolean)(((1)) != 0);
|
|
} else {
|
|
float var16 = Math.min(1.0F, var3 * 1.5F);
|
|
this.rainCoverage = this.rainCoverage + (var15 - this.rainCoverage) * var16;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateWetness(float var1) {
|
|
float var2 = this.frameActive ? this.localRainLevel() : 0.0F;
|
|
float var3 = var2 > this.wetness ? 0.22F : 0.08F;
|
|
float var4 = var3 * var1;
|
|
if (Math.abs(var2 - this.wetness) <= var4) {
|
|
this.wetness = var2;
|
|
} else {
|
|
this.wetness = this.wetness + (var2 > this.wetness ? var4 : -var4);
|
|
}
|
|
}
|
|
|
|
private void updateWind() {
|
|
double var1 = System.currentTimeMillis() % ((1606904270512999844L ^ -1606904270512399844L) + ((1606904270512999844L & -1606904270512399844L) << 1))
|
|
/ 1000.0;
|
|
double var3 = var1 * 0.035;
|
|
double var5 = 1.0 + Math.sin(var1 * 0.55) * 0.22F;
|
|
double var7 = this.windSetting.getCurrent() * 3.2F * var5;
|
|
this.windX = Math.cos(var3) * var7;
|
|
this.windZ = Math.sin(var3) * var7;
|
|
}
|
|
|
|
private void simulate(ClientLevel var1, Vec3 var2, float var3) {
|
|
float var4 = 0.0F;
|
|
int var5 = 0;
|
|
float var6 = 0.0F;
|
|
double var7 = 0.0;
|
|
int var9 = 0;
|
|
int var10 = 0;
|
|
double var11 = 0.0;
|
|
double var13 = 0.0;
|
|
double var15 = 0.0;
|
|
int var17 = 0;
|
|
int var18 = 0;
|
|
double var19 = 0.0;
|
|
double var21 = 0.0;
|
|
int var23 = 0;
|
|
int var25 = 0;
|
|
int var26 = 0;
|
|
int var27 = 0;
|
|
int var24 = -1702668442;
|
|
|
|
while (true) {
|
|
switch (var24) {
|
|
case -2111845729:
|
|
if (!this.respawn(var1, var2, var4, this.dropCount, (boolean)((var10) != 0))) {
|
|
var24 = 1465107542;
|
|
} else {
|
|
var24 = -1638188006;
|
|
}
|
|
break;
|
|
case -1981227364:
|
|
return;
|
|
case -1953930009:
|
|
var10--;
|
|
var24 = 1343196557;
|
|
break;
|
|
case -1859811814:
|
|
var23 = var26;
|
|
if (var23 != 0) {
|
|
var24 = 1407207288;
|
|
} else {
|
|
var24 = -736581033;
|
|
}
|
|
break;
|
|
case -1830941679:
|
|
var27 = 0;
|
|
var24 = -1813312644;
|
|
break;
|
|
case -1813312644:
|
|
var10 = var27;
|
|
var24 = -798881374;
|
|
break;
|
|
case -1788418718:
|
|
if (var18 != this.dropColumnZ[var10]) {
|
|
var24 = -1238353369;
|
|
} else {
|
|
var24 = -1080816591;
|
|
}
|
|
break;
|
|
case -1702668442:
|
|
default:
|
|
var4 = this.radiusSetting.getCurrent();
|
|
if (this.frameActive) {
|
|
var24 = -1682643138;
|
|
} else {
|
|
var24 = -705856084;
|
|
}
|
|
break;
|
|
case -1682643138:
|
|
var25 = this.targetDropCount(var4);
|
|
var24 = 264983089;
|
|
break;
|
|
case -1638188006:
|
|
this.dropCount += 1;
|
|
var24 = -798881374;
|
|
break;
|
|
case -1238353369:
|
|
this.dropColumnX[var10] = var17;
|
|
this.dropColumnZ[var10] = var18;
|
|
this.dropGround[var10] = var1.getHeight(Types.MOTION_BLOCKING, var17, var18);
|
|
if (!this.isRainColumn(var1, var17, var18, this.dropGround[var10])) {
|
|
var24 = -22799589;
|
|
} else {
|
|
var24 = -1080816591;
|
|
}
|
|
break;
|
|
case -1207288115:
|
|
if (var19 * var19 + var21 * var21 < 256.0) {
|
|
var24 = 654917378;
|
|
} else {
|
|
var24 = -736581033;
|
|
}
|
|
break;
|
|
case -1080816591:
|
|
var19 = var11 - var2.x;
|
|
var21 = var13 - var2.z;
|
|
if (var15 <= this.dropGround[var10]) {
|
|
var24 = 455631647;
|
|
} else {
|
|
var24 = -516997460;
|
|
}
|
|
break;
|
|
case -1078659993:
|
|
this.dropX[var10] = var11;
|
|
this.dropY[var10] = var15;
|
|
this.dropZ[var10] = var13;
|
|
var24 = -1953930009;
|
|
break;
|
|
case -798881374:
|
|
if (this.dropCount < var5) {
|
|
var24 = -2111845729;
|
|
} else {
|
|
var24 = -1981227364;
|
|
}
|
|
break;
|
|
case -736581033:
|
|
if (var23 == 0) {
|
|
var24 = 1025447260;
|
|
} else {
|
|
var24 = -84297901;
|
|
}
|
|
break;
|
|
case -705856084:
|
|
var25 = 0;
|
|
var24 = 264983089;
|
|
break;
|
|
case -668477482:
|
|
var27 = 1;
|
|
var24 = -1813312644;
|
|
break;
|
|
case -554224486:
|
|
if (var10 >= var5) {
|
|
var24 = -84297901;
|
|
} else {
|
|
var24 = -1078659993;
|
|
}
|
|
break;
|
|
case -516997460:
|
|
var26 = 0;
|
|
var24 = -1859811814;
|
|
break;
|
|
case -84297901:
|
|
if (var10 >= var5) {
|
|
var24 = 1974707866;
|
|
} else {
|
|
var24 = 1017384497;
|
|
}
|
|
break;
|
|
case -22799589:
|
|
if (this.respawn(var1, var2, var4, var10, (boolean)((((1632204534 | -1632204534) + (1632204534 & -1632204534))) != 0))) {
|
|
var24 = 715453318;
|
|
} else {
|
|
var24 = 1891302311;
|
|
}
|
|
break;
|
|
case 84721981:
|
|
if (this.dropCount == 0) {
|
|
var24 = -668477482;
|
|
} else {
|
|
var24 = -1830941679;
|
|
}
|
|
break;
|
|
case 264983089:
|
|
var5 = var25;
|
|
var6 = 9.0F * this.speedSetting.getCurrent();
|
|
var7 = var4 * 1.3 * var4 * 1.3;
|
|
var9 = (this.splashSetting.isEnabled()) ? 1 : 0;
|
|
var10 = this.dropCount - (1);
|
|
var24 = 1343196557;
|
|
break;
|
|
case 455631647:
|
|
var26 = 1;
|
|
var24 = -1859811814;
|
|
break;
|
|
case 546976679:
|
|
var11 = this.dropX[var10] + this.windX * var3;
|
|
var13 = this.dropZ[var10] + this.windZ * var3;
|
|
var15 = this.dropY[var10] - var6 * this.dropSpeed[var10] * var3;
|
|
var17 = Mth.floor(var11);
|
|
var18 = Mth.floor(var13);
|
|
if (var17 == this.dropColumnX[var10]) {
|
|
var24 = -1788418718;
|
|
} else {
|
|
var24 = -1238353369;
|
|
}
|
|
break;
|
|
case 654917378:
|
|
this.impactCounter += 1;
|
|
if (this.impactCounter % 2== 0) {
|
|
var24 = 1585321194;
|
|
} else {
|
|
var24 = -736581033;
|
|
}
|
|
break;
|
|
case 715453318:
|
|
var24 = -1953930009;
|
|
break;
|
|
case 990062336:
|
|
this.dropCount -= 1;
|
|
this.moveDrop(this.dropCount, var10);
|
|
var24 = -1953930009;
|
|
break;
|
|
case 1017384497:
|
|
if (!this.respawn(var1, var2, var4, var10, (boolean)((((-1337521546 ^ 1337521546) + ((-1337521546 & 1337521546) << 1))) != 0))) {
|
|
var24 = 990062336;
|
|
} else {
|
|
var24 = -1953930009;
|
|
}
|
|
break;
|
|
case 1025447260:
|
|
if (!(var19 * var19 + var21 * var21 > var7)) {
|
|
var24 = -554224486;
|
|
} else {
|
|
var24 = -84297901;
|
|
}
|
|
break;
|
|
case 1343196557:
|
|
if (var10 >= 0) {
|
|
var24 = 546976679;
|
|
} else {
|
|
var24 = 84721981;
|
|
}
|
|
break;
|
|
case 1407207288:
|
|
if (var9 != 0) {
|
|
var24 = -1207288115;
|
|
} else {
|
|
var24 = -736581033;
|
|
}
|
|
break;
|
|
case 1465107542:
|
|
var24 = -1981227364;
|
|
break;
|
|
case 1585321194:
|
|
this.addSplash(var11, this.dropGround[var10], var13);
|
|
var24 = -736581033;
|
|
break;
|
|
case 1891302311:
|
|
this.dropCount -= 1;
|
|
this.moveDrop(this.dropCount, var10);
|
|
var24 = -1953930009;
|
|
break;
|
|
case 1974707866:
|
|
this.dropCount -= 1;
|
|
this.moveDrop(this.dropCount, var10);
|
|
var24 = -1953930009;
|
|
}
|
|
}
|
|
}
|
|
|
|
private int targetDropCount(float var1) {
|
|
double var2 = Math.PI * var1 * var1;
|
|
return (int)Math.min(9000.0, var2 * this.densitySetting.getCurrent() * 4.0 * this.localRainLevel());
|
|
}
|
|
|
|
private void moveDrop(int var1, int var2) {
|
|
int var3 = -797317792;
|
|
|
|
while (true) {
|
|
switch (var3) {
|
|
case -797317792:
|
|
default:
|
|
if (var1 == var2) {
|
|
var3 = 381053169;
|
|
} else {
|
|
var3 = 1688698222;
|
|
}
|
|
break;
|
|
case 381053169:
|
|
return;
|
|
case 1688698222:
|
|
this.dropX[var2] = this.dropX[var1];
|
|
this.dropY[var2] = this.dropY[var1];
|
|
this.dropZ[var2] = this.dropZ[var1];
|
|
this.dropSpeed[var2] = this.dropSpeed[var1];
|
|
this.dropAlpha[var2] = this.dropAlpha[var1];
|
|
this.dropGround[var2] = this.dropGround[var1];
|
|
this.dropColumnX[var2] = this.dropColumnX[var1];
|
|
this.dropColumnZ[var2] = this.dropColumnZ[var1];
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean respawn(ClientLevel var1, Vec3 var2, float var3, int var4, boolean var5) {
|
|
ThreadLocalRandom var6 = ThreadLocalRandom.current();
|
|
|
|
for (int var7 = 0; var7 < 3; var7++) {
|
|
double var8 = var6.nextDouble() * (Math.PI * 2);
|
|
double var10 = var3 * Math.sqrt(var6.nextDouble());
|
|
double var12 = var2.x + Math.cos(var8) * var10;
|
|
double var14 = var2.z + Math.sin(var8) * var10;
|
|
int var16 = Mth.floor(var12);
|
|
int var17 = Mth.floor(var14);
|
|
float var18 = var1.getHeight(Types.MOTION_BLOCKING, var16, var17);
|
|
if (this.isRainColumn(var1, var16, var17, var18)) {
|
|
double var19 = var2.y + 9.0 + var6.nextDouble() * 3.0;
|
|
double var21 = Math.max(var18, var2.y - 6.0);
|
|
if (!(var19 <= var21)) {
|
|
this.dropX[var4] = var12;
|
|
this.dropZ[var4] = var14;
|
|
this.dropY[var4] = var5 ? var21 + var6.nextDouble() * (var19 - var21) : var19;
|
|
this.dropSpeed[var4] = (float)var6.nextDouble(0.82F, 1.18F);
|
|
this.dropAlpha[var4] = (float)var6.nextDouble(0.55F, 1.15F);
|
|
this.dropGround[var4] = var18;
|
|
this.dropColumnX[var4] = var16;
|
|
this.dropColumnZ[var4] = var17;
|
|
return (boolean)(((1)) != 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (boolean)(((0)) != 0);
|
|
}
|
|
|
|
private void addSplash(double var1, double var3, double var5) {
|
|
int var7 = 0;
|
|
int var8 = -116675638;
|
|
|
|
while (true) {
|
|
switch (var8) {
|
|
case -1126686000:
|
|
this.splashSize += 1;
|
|
var8 = 320990688;
|
|
break;
|
|
case -306560853:
|
|
this.splashHead = (this.splashHead + (391467823 ^ -391467822) + ((391467823 & -391467822) << 1))
|
|
% ((-1381027719 ^ 1381027847) + ((-1381027719 & 1381027847) << 1));
|
|
var8 = 320990688;
|
|
break;
|
|
case -116675638:
|
|
default:
|
|
var7 = (this.splashHead + this.splashSize) % (128);
|
|
if (this.splashSize < (-988744784 | 988744912) + (-988744784 & 988744912)) {
|
|
var8 = -1126686000;
|
|
} else {
|
|
var8 = -306560853;
|
|
}
|
|
break;
|
|
case 320990688:
|
|
this.splashX[var7] = var1;
|
|
this.splashY[var7] = var3;
|
|
this.splashZ[var7] = var5;
|
|
this.splashStart[var7] = System.currentTimeMillis();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void submitDroplets(SubmitNodeCollector var1, PoseStack var2, Camera var3, Vec3 var4, int var5) {
|
|
float var6 = 0.0F;
|
|
float var7 = 0.0F;
|
|
float var8 = 0.0F;
|
|
float var9 = 0.0F;
|
|
float var10 = 0.0F;
|
|
Vector3fc var11 = null;
|
|
float var12 = 0.0F;
|
|
float var13 = 0.0F;
|
|
float var14 = 0.0F;
|
|
int var15 = 0;
|
|
int var16 = 974474182;
|
|
|
|
while (true) {
|
|
switch (var16) {
|
|
case 582511943:
|
|
var6 = 9.0F * this.speedSetting.getCurrent();
|
|
var7 = this.sizeSetting.getCurrent();
|
|
var8 = var6 * 0.032F * var7;
|
|
var9 = 0.025F * var7;
|
|
var10 = this.opacitySetting.getCurrent() * this.frameRainLevel;
|
|
var11 = var3.forwardVector();
|
|
var12 = var11.x();
|
|
var13 = var11.y();
|
|
var14 = var11.z();
|
|
var15 = this.dropCount;
|
|
var1.submitCustomGeometry(var2, arj.positionColorDepthNoWrite(), (var11x, var12x) -> {
|
|
float var13x = 0.0F;
|
|
float var14x = 0.0F;
|
|
float var15x = 0.0F;
|
|
float var16x = 0.0F;
|
|
int var17x = 0;
|
|
float var18x = 0.0F;
|
|
float var19x = 0.0F;
|
|
float var20x = 0.0F;
|
|
float var21x = 0.0F;
|
|
float var22x = 0.0F;
|
|
float var23x = 0.0F;
|
|
float var24x = 0.0F;
|
|
float var25x = 0.0F;
|
|
float var26x = 0.0F;
|
|
float var27 = 0.0F;
|
|
float var28 = 0.0F;
|
|
float var29 = 0.0F;
|
|
float var30 = 0.0F;
|
|
float var31 = 0.0F;
|
|
float var32 = 0.0F;
|
|
float var33 = 0.0F;
|
|
float var34 = 0.0F;
|
|
float var35 = 0.0F;
|
|
int var36 = 0;
|
|
int var37 = 0;
|
|
int var38 = 0;
|
|
int var39 = -749415779;
|
|
|
|
while (true) {
|
|
switch (var39) {
|
|
case -1707118834:
|
|
var39 = 1825865055;
|
|
break;
|
|
case -1623409709:
|
|
var23x /= var26x;
|
|
var24x /= var26x;
|
|
var25x /= var26x;
|
|
var27 = Math.max(var9, var21x * 0.002F);
|
|
var28 = var8 * this.dropSpeed[var17x];
|
|
var29 = var10 * var22x * this.dropAlpha[var17x];
|
|
var30 = var18x - var14x * var28;
|
|
var31 = var19x - var15x * var28;
|
|
var32 = var20x - var16x * var28;
|
|
var33 = var18x - var14x * var28 * 0.45F;
|
|
var34 = var19x - var15x * var28 * 0.45F;
|
|
var35 = var20x - var16x * var28 * 0.45F;
|
|
var36 = withAlpha(var5, var29);
|
|
var37 = withAlpha(var5, var29 * 0.45F);
|
|
var38 = withAlpha(var5, 0.0F);
|
|
this.emitStreakSegment(var12x, var11x, var30, var31, var32, var33, var34, var35, var23x, var24x, var25x, var27, var38, var36);
|
|
this.emitStreakSegment(var12x, var11x, var33, var34, var35, var18x, var19x, var20x, var23x, var24x, var25x, var27, var36, var37);
|
|
var39 = 1825865055;
|
|
break;
|
|
case -1119169069:
|
|
var39 = 1825865055;
|
|
break;
|
|
case -959984870:
|
|
if (var17x < var15) {
|
|
var39 = 1174780233;
|
|
} else {
|
|
var39 = -360757082;
|
|
}
|
|
break;
|
|
case -838297494:
|
|
var39 = 1825865055;
|
|
break;
|
|
case -749415779:
|
|
default:
|
|
var13x = Mth.sqrt((float)(this.windX * this.windX + var6 * var6 + this.windZ * this.windZ));
|
|
var14x = (float)(this.windX / var13x);
|
|
var15x = -var6 / var13x;
|
|
var16x = (float)(this.windZ / var13x);
|
|
var17x = 0;
|
|
var39 = -959984870;
|
|
break;
|
|
case -526540266:
|
|
var39 = 1825865055;
|
|
break;
|
|
case -360757082:
|
|
return;
|
|
case 127055242:
|
|
var23x = var15x * (var20x / var21x) - var16x * (var19x / var21x);
|
|
var24x = var16x * (var18x / var21x) - var14x * (var20x / var21x);
|
|
var25x = var14x * (var19x / var21x) - var15x * (var18x / var21x);
|
|
var26x = Mth.sqrt(var23x * var23x + var24x * var24x + var25x * var25x);
|
|
if (var26x <= 1.0E-4F) {
|
|
var39 = -1119169069;
|
|
} else {
|
|
var39 = -1623409709;
|
|
}
|
|
break;
|
|
case 1086757984:
|
|
var22x = (float)Mth.clamp((var21x - 0.35) / 1.0499999999999998, 0.0, 1.0);
|
|
if (var22x <= 0.0F) {
|
|
var39 = -838297494;
|
|
} else {
|
|
var39 = 127055242;
|
|
}
|
|
break;
|
|
case 1174780233:
|
|
var18x = (float)(this.dropX[var17x] - var4.x);
|
|
var19x = (float)(this.dropY[var17x] - var4.y);
|
|
var20x = (float)(this.dropZ[var17x] - var4.z);
|
|
var21x = Mth.sqrt(var18x * var18x + var19x * var19x + var20x * var20x);
|
|
if (var21x <= 0.0F) {
|
|
var39 = -526540266;
|
|
} else {
|
|
var39 = 1585566084;
|
|
}
|
|
break;
|
|
case 1585566084:
|
|
if (var21x > 3.0) {
|
|
var39 = 2141588167;
|
|
} else {
|
|
var39 = 1086757984;
|
|
}
|
|
break;
|
|
case 1825865055:
|
|
var17x++;
|
|
var39 = -959984870;
|
|
break;
|
|
case 2141588167:
|
|
if ((var18x * var12 + var19x * var13 + var20x * var14) / var21x < -0.35F) {
|
|
var39 = -1707118834;
|
|
} else {
|
|
var39 = 1086757984;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return;
|
|
case 974474182:
|
|
default:
|
|
if (this.dropCount == 0) {
|
|
var16 = 1069285036;
|
|
} else {
|
|
var16 = 582511943;
|
|
}
|
|
break;
|
|
case 1069285036:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void submitSplashes(SubmitNodeCollector var1, PoseStack var2, Camera var3, Vec3 var4, int var5) {
|
|
long var6 = (-4021282502204837136L | 4021282502204837136L) + (-4021282502204837136L & 4021282502204837136L);
|
|
float var8 = 0.0F;
|
|
Vector3fc var9 = null;
|
|
int var10 = 0;
|
|
int var11 = 0;
|
|
int var12 = -1589099406;
|
|
|
|
while (true) {
|
|
switch (var12) {
|
|
case -1774646003:
|
|
if (var6 - this.splashStart[this.splashHead] >= (7560021694652587048L | -7560021694652586688L) + (7560021694652587048L & -7560021694652586688L)) {
|
|
var12 = -1399272457;
|
|
} else {
|
|
var12 = 420168679;
|
|
}
|
|
break;
|
|
case -1589099406:
|
|
default:
|
|
var6 = System.currentTimeMillis();
|
|
var12 = -1440701577;
|
|
break;
|
|
case -1440701577:
|
|
if (this.splashSize > 0) {
|
|
var12 = -1774646003;
|
|
} else {
|
|
var12 = 420168679;
|
|
}
|
|
break;
|
|
case -1399272457:
|
|
this.splashHead = (this.splashHead + (-534014017 | 534014018) + (-534014017 & 534014018))
|
|
% ((-1365495309 ^ 1365495437) + ((-1365495309 & 1365495437) << 1));
|
|
this.splashSize -= 1;
|
|
var12 = -1440701577;
|
|
break;
|
|
case -1298050998:
|
|
return;
|
|
case 420168679:
|
|
if (this.splashSize == 0) {
|
|
var12 = -1298050998;
|
|
} else {
|
|
var12 = 1578540374;
|
|
}
|
|
break;
|
|
case 1578540374:
|
|
var8 = 0.5F * this.opacitySetting.getCurrent() * Math.max(this.frameRainLevel, this.wetness);
|
|
var9 = var3.forwardVector();
|
|
var10 = this.splashSize;
|
|
var11 = this.splashHead;
|
|
var1.submitCustomGeometry(var2, arj.positionColorDepthNoWrite(), (var9x, var10x) -> {
|
|
int var11x = 0;
|
|
int var12x = 0;
|
|
float var13x = 0.0F;
|
|
double var14x = 0.0;
|
|
double var16x = 0.0;
|
|
double var18 = 0.0;
|
|
double var20 = 0.0;
|
|
float var22 = 0.0F;
|
|
float var23 = 0.0F;
|
|
float var24 = 0.0F;
|
|
int var25 = 0;
|
|
int var26 = 0;
|
|
double var27 = 0.0;
|
|
double var29 = 0.0;
|
|
float var31 = 0.0F;
|
|
float var32 = 0.0F;
|
|
float var33 = 0.0F;
|
|
float var34 = 0.0F;
|
|
int var35 = -1733669760;
|
|
|
|
while (true) {
|
|
switch (var35) {
|
|
case -2040229467:
|
|
if (var26 < (1173813447 ^ -1173813431) + ((1173813447 & -1173813431) << 1)) {
|
|
var35 = -1963987580;
|
|
} else {
|
|
var35 = 770879849;
|
|
}
|
|
break;
|
|
case -1963987580:
|
|
var27 = var26 / 16.0 * (Math.PI * 2);
|
|
var29 = (var26 + (403336631 | -403336630) + (403336631 & -403336630)) / 16.0 * (Math.PI * 2);
|
|
var31 = (float)Math.cos(var27);
|
|
var32 = (float)Math.sin(var27);
|
|
var33 = (float)Math.cos(var29);
|
|
var34 = (float)Math.sin(var29);
|
|
this.ringVertex(var10x, var9x, var14x, var16x, var18, var31 * var24, var32 * var24, var25);
|
|
this.ringVertex(var10x, var9x, var14x, var16x, var18, var31 * var23, var32 * var23, var25);
|
|
this.ringVertex(var10x, var9x, var14x, var16x, var18, var33 * var23, var34 * var23, var25);
|
|
this.ringVertex(var10x, var9x, var14x, var16x, var18, var33 * var24, var34 * var24, var25);
|
|
var26++;
|
|
var35 = -2040229467;
|
|
break;
|
|
case -1733669760:
|
|
default:
|
|
var11x = 0;
|
|
var35 = 746061916;
|
|
break;
|
|
case -295964581:
|
|
if ((var14x * var9.x() + var16x * var9.y() + var18 * var9.z()) / var20 < -0.35F) {
|
|
var35 = -117608828;
|
|
} else {
|
|
var35 = 78890872;
|
|
}
|
|
break;
|
|
case -170422428:
|
|
var12x = (var11 + var11x) % (128);
|
|
var13x = (float)(var6 - this.splashStart[var12x]) / 360.0F;
|
|
if (!(var13x < 0.0F)) {
|
|
var35 = 1779742863;
|
|
} else {
|
|
var35 = 770879849;
|
|
}
|
|
break;
|
|
case -117608828:
|
|
var35 = 770879849;
|
|
break;
|
|
case 78890872:
|
|
var22 = 1.0F - (1.0F - var13x) * (1.0F - var13x);
|
|
var23 = Mth.lerp(var22, 0.05F, 0.26F);
|
|
var24 = Math.max(0.0F, var23 - 0.032F);
|
|
var25 = withAlpha(var5, var8 * (1.0F - var13x) * (1.0F - var13x));
|
|
var26 = 0;
|
|
var35 = -2040229467;
|
|
break;
|
|
case 746061916:
|
|
if (var11x < var10) {
|
|
var35 = -170422428;
|
|
} else {
|
|
var35 = 778126713;
|
|
}
|
|
break;
|
|
case 770879849:
|
|
var11x++;
|
|
var35 = 746061916;
|
|
break;
|
|
case 778126713:
|
|
return;
|
|
case 819988945:
|
|
var14x = this.splashX[var12x] - var4.x;
|
|
var16x = this.splashY[var12x] + 0.012F - var4.y;
|
|
var18 = this.splashZ[var12x] - var4.z;
|
|
var20 = Math.sqrt(var14x * var14x + var16x * var16x + var18 * var18);
|
|
if (var20 > 3.0) {
|
|
var35 = -295964581;
|
|
} else {
|
|
var35 = 78890872;
|
|
}
|
|
break;
|
|
case 1779742863:
|
|
if (var13x >= 1.0F) {
|
|
var35 = 1790766996;
|
|
} else {
|
|
var35 = 819988945;
|
|
}
|
|
break;
|
|
case 1790766996:
|
|
var35 = 770879849;
|
|
}
|
|
}
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void emitStreakSegment(
|
|
VertexConsumer var1,
|
|
Pose var2,
|
|
float var3,
|
|
float var4,
|
|
float var5,
|
|
float var6,
|
|
float var7,
|
|
float var8,
|
|
float var9,
|
|
float var10,
|
|
float var11,
|
|
float var12,
|
|
int var13,
|
|
int var14
|
|
) {
|
|
int var15 = withAlpha(var13, 0.0F);
|
|
var1.addVertex(var2, var3 - var9 * var12, var4 - var10 * var12, var5 - var11 * var12).setColor(var15);
|
|
var1.addVertex(var2, var3, var4, var5).setColor(var13);
|
|
var1.addVertex(var2, var6, var7, var8).setColor(var14);
|
|
var1.addVertex(var2, var6 - var9 * var12, var7 - var10 * var12, var8 - var11 * var12).setColor(var15);
|
|
var1.addVertex(var2, var3, var4, var5).setColor(var13);
|
|
var1.addVertex(var2, var3 + var9 * var12, var4 + var10 * var12, var5 + var11 * var12).setColor(var15);
|
|
var1.addVertex(var2, var6 + var9 * var12, var7 + var10 * var12, var8 + var11 * var12).setColor(var15);
|
|
var1.addVertex(var2, var6, var7, var8).setColor(var14);
|
|
}
|
|
|
|
private void ringVertex(VertexConsumer var1, Pose var2, double var3, double var5, double var7, float var9, float var10, int var11) {
|
|
var1.addVertex(var2, (float)(var3 + var9), (float)var5, (float)(var7 + var10)).setColor(var11);
|
|
}
|
|
|
|
private void rebuildSurfaceCache(ClientLevel var1, Vec3 var2) {
|
|
int var3 = 0;
|
|
int var4 = 0;
|
|
int var5 = 0;
|
|
long var6 = (-4392906087481766760L | 4392906087481766760L) + (-4392906087481766760L & 4392906087481766760L);
|
|
int var8 = 0;
|
|
int var9 = 0;
|
|
int var10 = 0;
|
|
int var11 = 0;
|
|
int var12 = 0;
|
|
int var13 = 0;
|
|
int var14 = 0;
|
|
int var15 = 0;
|
|
int var16 = 0;
|
|
BlockState var17 = null;
|
|
float var18 = 0.0F;
|
|
VoxelShape var19 = null;
|
|
int var20 = 1396337572;
|
|
|
|
while (true) {
|
|
switch (var20) {
|
|
case -1906399943:
|
|
if (var4 == this.scanBlockX) {
|
|
var20 = 1820515524;
|
|
} else {
|
|
var20 = 1297692454;
|
|
}
|
|
break;
|
|
case -1858876294:
|
|
if (!var17.getFluidState().isEmpty()) {
|
|
var20 = -1305300979;
|
|
} else {
|
|
var20 = -514288863;
|
|
}
|
|
break;
|
|
case -1689625478:
|
|
var10 = var1.getMinY();
|
|
var11 = 0;
|
|
var12 = -var3;
|
|
var20 = -616547491;
|
|
break;
|
|
case -1305300979:
|
|
var18 = var16 - 0.12F;
|
|
var20 = 1868719283;
|
|
break;
|
|
case -616547491:
|
|
if (var12 <= var3) {
|
|
var20 = 941935422;
|
|
} else {
|
|
var20 = 1482975798;
|
|
}
|
|
break;
|
|
case -514288863:
|
|
var13++;
|
|
var20 = 931171988;
|
|
break;
|
|
case -296638661:
|
|
var20 = -514288863;
|
|
break;
|
|
case 312964364:
|
|
if (var12 * var12 + var13 * var13 > var3 * var3) {
|
|
var20 = -296638661;
|
|
} else {
|
|
var20 = 450668467;
|
|
}
|
|
break;
|
|
case 450668467:
|
|
var14 = var4 + var12;
|
|
var15 = var5 + var13;
|
|
var16 = var1.getHeight(Types.MOTION_BLOCKING, var14, var15);
|
|
if (var16 <= var10) {
|
|
var20 = 1234858834;
|
|
} else {
|
|
var20 = 1676482937;
|
|
}
|
|
break;
|
|
case 551389047:
|
|
var20 = -514288863;
|
|
break;
|
|
case 931171988:
|
|
if (var13 <= var3) {
|
|
var20 = 312964364;
|
|
} else {
|
|
var20 = 1850772046;
|
|
}
|
|
break;
|
|
case 941935422:
|
|
var13 = -var3;
|
|
var20 = 931171988;
|
|
break;
|
|
case 1012295225:
|
|
var19 = var17.getCollisionShape(var1, this.scanPos);
|
|
if (!var19.isEmpty()) {
|
|
var20 = 1843944448;
|
|
} else {
|
|
var20 = -1858876294;
|
|
}
|
|
break;
|
|
case 1234858834:
|
|
var20 = -514288863;
|
|
break;
|
|
case 1262314971:
|
|
return;
|
|
case 1297692454:
|
|
this.scanRadius = var3;
|
|
this.scanBlockX = var4;
|
|
this.scanBlockZ = var5;
|
|
this.scanTime = var6;
|
|
var8 = var3 * 3;
|
|
var9 = var8 * var8;
|
|
if (this.columnX.length < var9) {
|
|
var20 = 1903622289;
|
|
} else {
|
|
var20 = -1689625478;
|
|
}
|
|
break;
|
|
case 1396337572:
|
|
default:
|
|
var3 = (int)this.wetRadiusSetting.getCurrent();
|
|
var4 = Mth.floor(var2.x);
|
|
var5 = Mth.floor(var2.z);
|
|
var6 = System.currentTimeMillis();
|
|
if (var3 == this.scanRadius) {
|
|
var20 = -1906399943;
|
|
} else {
|
|
var20 = 1297692454;
|
|
}
|
|
break;
|
|
case 1482975798:
|
|
this.columnCount = var11;
|
|
return;
|
|
case 1646560443:
|
|
if (var6 - this.scanTime < (-6829848025742156788L | 6829848025742157488L) + (-6829848025742156788L & 6829848025742157488L)) {
|
|
var20 = 1262314971;
|
|
} else {
|
|
var20 = 1297692454;
|
|
}
|
|
break;
|
|
case 1676482937:
|
|
this.scanPos.set(var14, var16 - (1), var15);
|
|
var17 = var1.getBlockState(this.scanPos);
|
|
if (var17.isAir()) {
|
|
var20 = 551389047;
|
|
} else {
|
|
var20 = 1012295225;
|
|
}
|
|
break;
|
|
case 1820515524:
|
|
if (var5 == this.scanBlockZ) {
|
|
var20 = 1646560443;
|
|
} else {
|
|
var20 = 1297692454;
|
|
}
|
|
break;
|
|
case 1843944448:
|
|
var18 = var16 - ((608909556 ^ -608909555) + ((608909556 & -608909555) << 1)) + (float)var19.max(Axis.Y);
|
|
var20 = 1868719283;
|
|
break;
|
|
case 1850772046:
|
|
var12++;
|
|
var20 = -616547491;
|
|
break;
|
|
case 1868719283:
|
|
this.columnX[var11] = var14;
|
|
this.columnZ[var11] = var15;
|
|
this.columnY[var11] = var18;
|
|
var11++;
|
|
var20 = -514288863;
|
|
break;
|
|
case 1903622289:
|
|
this.columnX = new int[var9];
|
|
this.columnZ = new int[var9];
|
|
this.columnY = new float[var9];
|
|
var20 = -1689625478;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void emitSurfaceQuads(BufferBuilder var1, Camera var2, Vec3 var3) {
|
|
float var4 = 0.0F;
|
|
float var5 = 0.0F;
|
|
Vector3fc var6 = null;
|
|
int var7 = 0;
|
|
double var8 = 0.0;
|
|
double var10 = 0.0;
|
|
double var12 = 0.0;
|
|
double var14 = 0.0;
|
|
double var16 = 0.0;
|
|
double var18 = 0.0;
|
|
float var20 = 0.0F;
|
|
double var21 = 0.0;
|
|
int var23 = 0;
|
|
float var24 = 0.0F;
|
|
float var25 = 0.0F;
|
|
float var26 = 0.0F;
|
|
float var27 = 0.0F;
|
|
float var28 = 0.0F;
|
|
int var29 = -569119899;
|
|
|
|
while (true) {
|
|
switch (var29) {
|
|
case -1872868476:
|
|
var8 = this.columnX[var7] - var3.x;
|
|
var10 = this.columnZ[var7] - var3.z;
|
|
var12 = this.columnY[var7] + 0.012F - var3.y;
|
|
var14 = var8 + 0.5;
|
|
var16 = var10 + 0.5;
|
|
var18 = Math.sqrt(var14 * var14 + var16 * var16);
|
|
var20 = 1.0F - Mth.clamp((float)((var18 - var5) / Math.max(var4 - var5, 1.0F)), 0.0F, 1.0F);
|
|
if (var20 <= 0.0F) {
|
|
var29 = 1473416495;
|
|
} else {
|
|
var29 = 963512850;
|
|
}
|
|
break;
|
|
case -1707285272:
|
|
if ((var14 * var6.x() + var12 * var6.y() + var16 * var6.z()) / var21 < -0.35F) {
|
|
var29 = 1841212834;
|
|
} else {
|
|
var29 = -991741743;
|
|
}
|
|
break;
|
|
case -1225009822:
|
|
var7++;
|
|
var29 = -502118957;
|
|
break;
|
|
case -991741743:
|
|
var23 = withAlpha(16777215, var20);
|
|
var24 = (float)var8;
|
|
var25 = (float)var10;
|
|
var26 = (float)(var8 + 1.0);
|
|
var27 = (float)(var10 + 1.0);
|
|
var28 = (float)var12;
|
|
var1.addVertex(var24, var28, var25).setColor(var23);
|
|
var1.addVertex(var24, var28, var27).setColor(var23);
|
|
var1.addVertex(var26, var28, var27).setColor(var23);
|
|
var1.addVertex(var26, var28, var25).setColor(var23);
|
|
var29 = -1225009822;
|
|
break;
|
|
case -963407174:
|
|
return;
|
|
case -569119899:
|
|
default:
|
|
var4 = this.scanRadius;
|
|
var5 = var4 * 0.62F;
|
|
var6 = var2.forwardVector();
|
|
var7 = 0;
|
|
var29 = -502118957;
|
|
break;
|
|
case -502118957:
|
|
if (var7 < this.columnCount) {
|
|
var29 = -1872868476;
|
|
} else {
|
|
var29 = -963407174;
|
|
}
|
|
break;
|
|
case 963512850:
|
|
var21 = Math.sqrt(var14 * var14 + var12 * var12 + var16 * var16);
|
|
if (var21 > 3.0) {
|
|
var29 = -1707285272;
|
|
} else {
|
|
var29 = -991741743;
|
|
}
|
|
break;
|
|
case 1473416495:
|
|
var29 = -1225009822;
|
|
break;
|
|
case 1841212834:
|
|
var29 = -1225009822;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static float wrapCoordinate(double var0) {
|
|
return (float)(var0 - Math.floor(var0 / 1024.0) * 1024.0);
|
|
}
|
|
|
|
private static int withAlpha(int var0, float var1) {
|
|
return Mth.clamp(
|
|
Math.round(var1 * 255.0F), 0, (-377292827 ^ 377293082) + ((-377292827 & 377293082) << 1)
|
|
)
|
|
<< (-1593619621 | 1593619645) + (-1593619621 & 1593619645)
|
|
| var0 & 16777215;
|
|
}
|
|
}
|