when did i last touch iridescence on this branch :O

common/src/main/java/net/lerariemann/infinity/iridescence/Iridescence.java

···
 import net.lerariemann.infinity.entity.custom.ChaosCreeper;
 import net.lerariemann.infinity.entity.custom.ChaosPawn;
 import net.lerariemann.infinity.util.InfinityMethods;
-import net.lerariemann.infinity.util.core.RandomProvider;
+import net.lerariemann.infinity.util.loading.ShaderLoader;
 import net.lerariemann.infinity.util.teleport.WarpLogic;
 import net.minecraft.block.Block;
 import net.minecraft.entity.EntityType;
···
         return stack.isIn(ModTags.IRIDESCENT_ITEMS);
     }
 
-    public static boolean isUnderEffect(LivingEntity entity) {
+    static boolean isUnderEffect(LivingEntity entity) {
         return entity.hasStatusEffect(ModStatusEffects.IRIDESCENT_EFFECT.value());
     }
 
···
         StatusEffectInstance cooldown = entity.getStatusEffect(ModStatusEffects.IRIDESCENT_COOLDOWN.value());
         if (cooldown == null) return original;
         else if (cooldown.getAmplifier() < 1) {
-            if (original > 0) return 0;
+            if (original > 0) return original / 2;
         }
         return -1;
     }
 
     static int getFullEffectLength(int amplifier) {
-        return getOnsetLength() + getEffectLength(amplifier);
+        return getOnsetLength(amplifier) + getEffectLength(amplifier);
     }
     static int getEffectLength(int amplifier) { //amplifier is 0 to 4
-        return getComeupLength() + getPeakLength(amplifier) + getOffsetLength(); //8 to 12 minutes
+        return getComeupLength() + getPeakLength(amplifier) + getOffsetLength(amplifier);
     }
-    static int getOnsetLength() {
-        return ticksInHour * RandomProvider.ruleInt("iridescenceInitialDuration") / 60; //default is 30 seconds
+    static int getOnsetLength(int amplifier) {
+        return ticksInHour * Math.max(20, 60 - 5*amplifier) / 120;
     }
     static int getComeupLength() {
         return ticksInHour;
···
     static int getPeakLength(int amplifier) {
         return ticksInHour * (4 + amplifier);
     }
-    static int getOffsetLength() {
-        return ticksInHour * 3;
+    static int getOffsetLength(int amplifier) {
+        return ticksInHour * (4 + amplifier) / 2;
     }
     static int getAfterglowDuration() {
-        return ticksInHour * RandomProvider.ruleInt("afterglowDuration"); //default is 24 minutes
+        int minDuration = ticksInHour * 20;
+        return (int)Math.floor(minDuration * Math.pow(2, InfinityMod.random.nextDouble(-1, 1)));
     }
     static int getCooldownDuration() {
-        return ticksInHour * RandomProvider.ruleInt("iridescenceCooldownDuration"); //default is 7*24 minutes
+        return ticksInHour * 7 * 20;
     }
 
     enum Phase {
···
         DOWNWARDS
     }
 
-    public static Phase getPhase(LivingEntity entity) {
+    static void updateAtomics(int duration, int amplifier) {
+        ShaderLoader.iridLevel.set(amplifier);
+        ShaderLoader.iridProgress.set(switch (getPhase(duration, amplifier)) {
+            case INITIAL -> 0.0;
+            case UPWARDS -> (getEffectLength(amplifier) - duration) / (1.0 * getComeupLength());
+            case PLATEAU -> 1.0;
+            case DOWNWARDS -> duration / (1.0 * getOffsetLength(amplifier));
+        });
+    }
+
+    static Phase getPhase(LivingEntity entity) {
         StatusEffectInstance effect = entity.getStatusEffect(ModStatusEffects.IRIDESCENT_EFFECT.value());
         if (effect == null) return Phase.INITIAL;
         return getPhase(effect.getDuration(), effect.getAmplifier());
···
     static Phase getPhase(int duration, int amplifier) {
         int time_passed = getEffectLength(amplifier) - duration;
         if (time_passed < 0) return Phase.INITIAL;
-        return (time_passed < getComeupLength()) ? Phase.UPWARDS : (duration <= getOffsetLength() || amplifier == 0) ? Phase.DOWNWARDS : Phase.PLATEAU;
+        return (time_passed < getComeupLength()) ? Phase.UPWARDS : (duration <= getOffsetLength(amplifier) || amplifier == 0) ? Phase.DOWNWARDS : Phase.PLATEAU;
     }
 
     static boolean shouldWarp(int duration, int amplifier) {
         return (Iridescence.getPhase(duration, amplifier) == Iridescence.Phase.PLATEAU) && (duration % ticksInHour == 0);
     }
     static boolean shouldReturn(int duration, int amplifier) {
-        return (amplifier > 0) && (duration == getOffsetLength());
+        return (amplifier > 0) && (duration == getOffsetLength(amplifier));
     }
     static boolean shouldRequestShaderLoad(int duration, int amplifier) {
         int time_passed = getEffectLength(amplifier) - duration;
         return (time_passed == 0);
     }
 
-    public static void loadShader(ServerPlayerEntity player) {
+    static void loadShader(ServerPlayerEntity player) {
         ServerPlayNetworking.send(player, ModPayloads.SHADER_RELOAD, ModPayloads.buildPacket(player.getServerWorld(), true));
     }
-    public static void unloadShader(ServerPlayerEntity player) {
+    static void unloadShader(ServerPlayerEntity player) {
         ServerPlayNetworking.send(player, ModPayloads.SHADER_RELOAD, ModPayloads.buildPacket(player.getServerWorld(), false));
     }
 
···
     }
 
     static void endJourney(ServerPlayerEntity player, boolean isEarlyCancel, int amplifier) {
-        player.setInvulnerable(false);
         if (!isEarlyCancel) {
             player.increaseStat(ModStats.IRIDESCENCE, 1);
             if (amplifier != 0)
···
         return (convertibles.containsKey(entity.getType()) || (entity instanceof ChaosPawn pawn && pawn.isBlackOrWhite()));
     }
 
-    public static void tryApplyEffect(MobEntity ent) {
+    static void tryApplyEffect(MobEntity ent) {
         if (!ent.hasStatusEffect(ModStatusEffects.IRIDESCENT_EFFECT.value())) {
             if (ent instanceof FishEntity)
                 ent.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT.value(), ticksInHour, 0,

common/src/main/java/net/lerariemann/infinity/iridescence/IridescentEffect.java

···
 package net.lerariemann.infinity.iridescence;
 
+import net.lerariemann.infinity.InfinityMod;
 import net.lerariemann.infinity.entity.custom.ChaosPawn;
+import net.lerariemann.infinity.util.core.RandomProvider;
+import net.lerariemann.infinity.util.loading.ShaderLoader;
 import net.lerariemann.infinity.util.teleport.WarpLogic;
 import net.lerariemann.infinity.registry.core.ModStatusEffects;
 import net.minecraft.entity.LivingEntity;
···
 import net.minecraft.entity.mob.Angerable;
 import net.minecraft.entity.mob.MobEntity;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.particle.ParticleEffect;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.util.Identifier;
···
         if (Objects.requireNonNull(entity) instanceof PlayerEntity player) {
             if (player instanceof ServerPlayerEntity serverPlayer) {
                 unloadShader(serverPlayer);
-                if (player.isInvulnerable()) endJourney(serverPlayer, true, 0);
+                player.setInvulnerable(false);
+                if (Iridescence.getPhase(entity) == Iridescence.Phase.PLATEAU) endJourney(serverPlayer, true, 0);
             }
         } else if (entity instanceof ChaosPawn pawn) {
             if (pawn.getRandom().nextBoolean()) {
···
         if (entity instanceof PlayerEntity player) {
             if (player instanceof ServerPlayerEntity serverPlayer) {
                 if (shouldWarp(duration, amplifier)) {
-                    if (!player.isInvulnerable()) {
-                        player.setInvulnerable(true);
+                    if (Iridescence.getPhase(duration + ticksInHour, amplifier) != Iridescence.Phase.PLATEAU) { //the first warp
+                        if (RandomProvider.rule("iridSafeMode")) player.setInvulnerable(true);
                         saveCookie(serverPlayer);
                     }
                     Identifier id = getIdForWarp(serverPlayer);
                     WarpLogic.requestWarp(serverPlayer, id, false);
                 }
                 if (shouldReturn(duration, amplifier)) {
+                    player.setInvulnerable(false);
                     endJourney(serverPlayer, false, amplifier);
                 }
                 if (shouldRequestShaderLoad(duration, amplifier))
                     loadShader(serverPlayer);
+
+                if (amplifier == 0 && duration == 2) {
+                    player.addStatusEffect(new StatusEffectInstance(ModStatusEffects.AFTERGLOW.value(),
+                            getAfterglowDuration() / 2, 0, true, true));
+                }
             }
-            if (amplifier == 0 && duration == 2) {
-                player.addStatusEffect(new StatusEffectInstance(ModStatusEffects.AFTERGLOW.value(),
-                        getAfterglowDuration() / 2, 0, true, true));
+            else {
+                Iridescence.updateAtomics(duration, amplifier);
+                if (amplifier == 0) return;
+                double prog = ShaderLoader.iridProgress.get();
+                if (prog > 0.5) {
+                    if (InfinityMod.random.nextDouble() < 0.015*(2*prog - 1)*amplifier)
+                        entity.playSound(SoundEvents.BLOCK_AMETHYST_BLOCK_CHIME, 1.0f, 1f + InfinityMod.random.nextFloat());
+                }
             }
         }
     }

common/src/main/java/net/lerariemann/infinity/item/IridescentPotionItem.java

···
 import java.util.List;
 
 public class IridescentPotionItem extends Item {
-    public IridescentPotionItem(Settings settings) {
+    int level;
+
+    public IridescentPotionItem(Settings settings, int level) {
         super(settings);
+        this.level = level;
     }
 
     @Override
···
 
     @Override
     public ItemStack finishUsing(ItemStack stack, World world, LivingEntity user) {
-        int level = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.F4_CHARGE, 0);
+        int level = BackportMethods.getOrDefaultInt(stack, ModComponentTypes.F4_CHARGE, -1);
+        if (level < 0) level = this.level;
         if (!world.isClient) Iridescence.tryBeginJourney(user, level, true);
         if (user instanceof PlayerEntity player) {
             if (user instanceof ServerPlayerEntity spe) {
···
                 stack.decrement(1);
                 player.getInventory().insertStack(new ItemStack(Items.GLASS_BOTTLE));
             }
-
         }
         else if (stack.isEmpty()) {
             return new ItemStack(Items.GLASS_BOTTLE);

common/src/main/java/net/lerariemann/infinity/mixin/iridescence/PostEffectProcessorMixin.java

···
 package net.lerariemann.infinity.mixin.iridescence;
 
+import net.lerariemann.infinity.util.loading.ShaderLoader;
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gl.PostEffectPass;
 import net.minecraft.client.gl.PostEffectProcessor;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.time.LocalTime;
 import java.util.List;
 
 @Mixin(PostEffectProcessor.class)
···
     @Shadow
     private float lastTickDelta;
 
+    @Unique
+    public void infinity$setUniforms(String name, float value) {
+        for (PostEffectPass postEffectPass : this.passes) {
+            postEffectPass.getProgram().getUniformByNameOrDummy(name).set(value);
+        }
+    }
+
     /* Hook for the iridescence shader to receive the time uniform */
     @Inject(method="render", at = @At("HEAD"), cancellable = true)
     void inj(float tickDelta, CallbackInfo ci) {
         if (name.contains("infinity")) {
+            infinity$setUniforms("IridTimeSec", ((int)(LocalTime.now().toNanoOfDay() / 1000000)) / 1000.0f);
+            infinity$setUniforms("IridLevel", ShaderLoader.iridLevel.get());
+            infinity$setUniforms("IridProgress", (float)ShaderLoader.iridProgress.get());
+            infinity$setUniforms("IridDistortion", MinecraftClient.getInstance().options.getDistortionEffectScale().getValue().floatValue());
             if (tickDelta < this.lastTickDelta) {
                 this.time += 1.0F - this.lastTickDelta;
                 this.time += tickDelta;

common/src/main/java/net/lerariemann/infinity/registry/core/ModItems.java

···
             registerItemAfter("f4", ItemGroups.TOOLS, Items.WRITABLE_BOOK, F4Item::new,
                     new Item.Settings().rarity(Rarity.UNCOMMON));
     public static final RegistrySupplier<Item> IRIDESCENT_POTION =
-            registerItemAfter("iridescent_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, IridescentPotionItem::new,
+            registerItemAfter("iridescent_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, (s) -> new IridescentPotionItem(s, 4),
                     new Item.Settings());
     public static final RegistrySupplier<Item> CHROMATIC_POTION =
-            registerItemAfter("chromatic_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, IridescentPotionItem::new,
+            registerItemAfter("chromatic_potion", ItemGroups.FOOD_AND_DRINK, Items.HONEY_BOTTLE, (s) -> new IridescentPotionItem(s, 0),
                     new Item.Settings());
 
     public static <T extends Item> RegistrySupplier<T> register(String item, Item.Settings settings, Function<Item.Settings, T> constructor) {

common/src/main/java/net/lerariemann/infinity/util/loading/ShaderLoader.java

···
 package net.lerariemann.infinity.util.loading;
 
+import com.google.common.util.concurrent.AtomicDouble;
 import net.fabricmc.api.EnvType;
 import net.fabricmc.api.Environment;
 import net.lerariemann.infinity.access.GameRendererAccess;
···
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicInteger;
 
 @Environment(EnvType.CLIENT)
 public interface ShaderLoader {
     String FILENAME = "current.json";
+    AtomicInteger iridLevel = new AtomicInteger(-1);
+    AtomicDouble iridProgress = new AtomicDouble(0.0);
+
     static Path shaderDir(MinecraftClient client) {
         return client.getResourcePackDir().resolve("infinity/assets/infinity/shaders");
     }
···
             ((GameRendererAccess)(client.gameRenderer)).infinity$loadPP(InfinityMethods.getId("shaders/post/iridescence.json"));
             return;
         }
+        iridLevel.set(-1);
+        iridProgress.set(0.0);
         try {
-            load(client);
+            updateWorldShaderFromDisk(client);
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
···
         client.gameRenderer.disablePostProcessor();
     }
 
-    static void load(MinecraftClient client) throws IOException {
+    static void updateWorldShaderFromDisk(MinecraftClient client) throws IOException {
         ResourcePackManager m = client.getResourcePackManager();
         Path path = client.getResourcePackDir().resolve("infinity");
         String name = "file/" + path.getFileName().toString();

common/src/main/resources/assets/infinity/shaders/program/color_wheel.fsh

···
 #version 150
 precision mediump float;
 uniform float Time; //0 to 1
+uniform float IridTimeSec;
+uniform float IridLevel;
+uniform float IridProgress;
+uniform float IridDistortion;
 uniform sampler2D DiffuseSampler;
 
 in vec2 texCoord;
···
 
 float random (in vec3 st) {
     return fract(sin(dot(st,
-                         vec3(12.9898,78.233,4.1414)))*
-                 43758.5453123);
+    vec3(12.9898,78.233,4.1414)))*
+    43758.5453123);
 }
 float noise (in vec3 st) {
     vec3 i = floor(st);
···
 
     vec3 u = f * f * (3.0 - 2.0 * f);
     return mix(
-        mix(
-            mix(a, b, u.x),
-            mix(c, d, u.x),
-            u.y),
-        mix(
-            mix(a1, b1, u.x),
-            mix(c1, d1, u.x),
-            u.y),
-        u.z);
+    mix(
+    mix(a, b, u.x),
+    mix(c, d, u.x),
+    u.y),
+    mix(
+    mix(a1, b1, u.x),
+    mix(c1, d1, u.x),
+    u.y),
+    u.z);
 }
 
 void main() {
-    vec4 InTexel = texture(DiffuseSampler, texCoord);
-    float time = 2*Time*3.1415f;
-    float iTime = 10*time + 1.5*noise(vec3(1.5*screenCoords, 3*(time > 0.5 ? 1 - time : time)));
+    float noiseScale1 = 1.0f + IridLevel/2.0f; //1 to 3
+    float noiseScale2 = 1.5f + IridLevel/4.0f; //1.5 to 2.5
+
+    float twopi = 6.2832f;
+    float time = twopi*(IridTimeSec / 10.0f);
+    float alpha = IridProgress > 0.5 ? 1 : 2*IridProgress;
+
+    float primaryColor = 2*fract(IridTimeSec / 20.0f);
+    primaryColor = twopi*alpha*((primaryColor > 1) ? 2 - primaryColor : primaryColor);
+    if (fract(IridTimeSec / 40.0f) > 0.5) primaryColor = -primaryColor;
+
+    float iTime = primaryColor + IridProgress*noiseScale2*noise(vec3(noiseScale1*screenCoords, 0.2*noiseScale2*time));
+
     float a = (1.0f - cos(iTime))/3.0f + cos(iTime);
     float b = (1.0f - cos(iTime))/3.0f - sin(iTime) / sqrt(3);
     float c = (1.0f - cos(iTime))/3.0f + sin(iTime) / sqrt(3);
 
+    float warpScale = 0.1 * IridDistortion * IridProgress * IridLevel / 12;
+    float edgeFactor = 1 - 2*min(min(texCoord.x, 1 - texCoord.x), min(texCoord.y, 1 - texCoord.y));
+    float texOffsetX = noise(vec3(3*screenCoords, 0.5*(time + 10000))) - 0.5;
+    float texOffsetY = noise(vec3(3*screenCoords, 0.5*(time - 10000))) - 0.5;
+    vec2 finalCoord = texCoord + warpScale*(1 - edgeFactor*edgeFactor)*vec2(texOffsetX, texOffsetY);
+    vec4 InTexel = texture(DiffuseSampler, finalCoord);
+
     float RedValue = dot(InTexel.rgb, vec3(a, b, c));
     float GreenValue = dot(InTexel.rgb, vec3(c, a, b));
     float BlueValue = dot(InTexel.rgb, vec3(b, c, a));
···
 
     float Luma = dot(OutColor, vec3(0.3, 0.59, 0.11));
     vec3 Chroma = OutColor - Luma;
-    OutColor = (Chroma * 1.8) + Luma;
+    OutColor = Chroma * (1 + alpha*(0.5 + 0.1*IridLevel)) + Luma;
 
     fragColor = vec4(OutColor, 1.0);
 }

common/src/main/resources/assets/infinity/shaders/program/color_wheel.json

···
     { "name": "ProjMat",     "type": "matrix4x4", "count": 16, "values": [ 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0 ] },
     { "name": "InSize",      "type": "float",     "count": 2,  "values": [ 1.0, 1.0 ] },
     { "name": "OutSize",     "type": "float",     "count": 2,  "values": [ 1.0, 1.0 ] },
-    { "name": "Time",     "type": "float",    "count": 1,  "values": [ 0.01 ]}
+    { "name": "Time",     "type": "float",    "count": 1,  "values": [ 0.01 ]},
+    { "name": "IridTimeSec",     "type": "float",    "count": 1,  "values": [ 0.0 ]},
+    { "name": "IridLevel",     "type": "float",    "count": 1,  "values": [ 0.0 ]},
+    { "name": "IridProgress",     "type": "float",    "count": 1,  "values": [ 0.0 ]},
+    { "name": "IridDistortion",     "type": "float",    "count": 1,  "values": [ 0.0 ]}
   ]
 }

common/src/main/resources/config/infinity.json

···
 {
-  "infinity_version": 2004003,
+  "infinity_version": 2004007,
   "gameRules": {
     "runtimeGenerationEnabled": true,
     "longArithmeticEnabled": false,
···
     "pawnsCanDropIllegalItems": false,
     "useSoundSyncPackets": true,
     "enforceModLoadedChecks": true,
+    "iridSafeMode": false,
     "maxBiomeCount": 6,
     "maxDimensionScale": 0,
     "avgDimensionHeight": 256,
-    "iridescenceInitialDuration": 30,
-    "iridescenceCooldownDuration": 168,
-    "afterglowDuration": 24,
     "resetChargeCooldown": 6000
   },
   "disabledDimensions": ["ant", "bash", "checkerboard",

gradle.properties

···
 org.gradle.parallel=true
 
 # Mod properties
-mod_version = 2.4.6
+mod_version = 2.4.7
 maven_group = net.lerariemann
 archives_name = infinity
 enabled_platforms = fabric,forge