dynamic lights compat

FalsePattern · Dec 4, 2023 · 9126b40 · 9126b40
1 parent db6d8e3
commit 9126b40
Show file tree

Hide file tree

Showing 12 changed files with 142 additions and 11 deletions.
diff --git a/src/main/java/com/falsepattern/falsetweaks/Compat.java b/src/main/java/com/falsepattern/falsetweaks/Compat.java
@@ -37,6 +37,7 @@
 public class Compat {
     private static Boolean NEODYMIUM = null;
     private static Boolean OPTIFINE = null;
+    private static Boolean DYNLIGHTS = null;
     private static Boolean SHADERS = null;
 
     public static boolean neodymiumInstalled() {
@@ -66,6 +67,22 @@ public static boolean optiFineInstalled() {
         return OPTIFINE;
     }
 
+    public static boolean optiFineHasDynamicLights() {
+        if (!optiFineInstalled()) {
+            return false;
+        }
+        if (DYNLIGHTS != null) {
+            return DYNLIGHTS;
+        }
+        try {
+            DYNLIGHTS = Launch.classLoader.getClassBytes("DynamicLights") != null;
+        } catch (IOException e) {
+            e.printStackTrace();
+            DYNLIGHTS = false;
+        }
+        return DYNLIGHTS;
+    }
+
     public static boolean optiFineHasShaders() {
         if (!optiFineInstalled()) {
             return false;

diff --git a/...lsepattern/falsetweaks/mixin/mixins/client/threadedupdates/optifine/WorldClientMixin.java b/...lsepattern/falsetweaks/mixin/mixins/client/threadedupdates/optifine/WorldClientMixin.java
@@ -0,0 +1,36 @@
+package com.falsepattern.falsetweaks.mixin.mixins.client.threadedupdates.optifine;
+
+import org.spongepowered.asm.mixin.Dynamic;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.profiler.Profiler;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldProvider;
+import net.minecraft.world.WorldSettings;
+import net.minecraft.world.storage.ISaveHandler;
+
+import static com.falsepattern.falsetweaks.modules.threadedupdates.ThreadedChunkUpdateHelper.MAIN_THREAD;
+
+@Mixin(WorldClient.class)
+public abstract class WorldClientMixin extends World {
+    @Dynamic
+    @Shadow(remap = false)
+    public boolean renderItemInFirstPerson;
+
+    public WorldClientMixin(ISaveHandler p_i45368_1_, String p_i45368_2_, WorldProvider p_i45368_3_, WorldSettings p_i45368_4_, Profiler p_i45368_5_) {
+        super(p_i45368_1_, p_i45368_2_, p_i45368_3_, p_i45368_4_, p_i45368_5_);
+    }
+
+    @Dynamic
+    @Redirect(method = {"getLightBrightnessForSkyBlocks", "func_72802_i"},
+              at = @At(value = "FIELD",
+                       target = "Lnet/minecraft/client/multiplayer/WorldClient;renderItemInFirstPerson:Z"),
+              require = 1)
+    private boolean noHandLightOffThread(WorldClient self) {
+        return renderItemInFirstPerson && Thread.currentThread() == MAIN_THREAD;
+    }
+}
diff --git a/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/Extras.java b/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/Extras.java
@@ -24,4 +24,5 @@
 class Extras {
     static final Predicate<String> OPTIFINE_SHADERSMOD_VERSIONS =
             contains("d7").or(contains("d8")).or(contains("e3")).or(contains("e7"));
+    static final Predicate<String> OPTIFINE_DYNAMIC_LIGHTS_VERSIONS = contains("d6");
 }
diff --git a/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/Mixin.java b/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/Mixin.java
@@ -33,7 +33,10 @@
 import static com.falsepattern.falsetweaks.mixin.plugin.standard.Mixin.CommonConfigs.TRIANGULATOR;
 import static com.falsepattern.falsetweaks.mixin.plugin.standard.Mixin.CommonConfigs.VOXELIZER;
 import static com.falsepattern.falsetweaks.mixin.plugin.standard.TargetedMod.AVOID_ANY_OPTIFINE;
+import static com.falsepattern.falsetweaks.mixin.plugin.standard.TargetedMod.AVOID_OPTIFINE_WITH_SHADERS;
 import static com.falsepattern.falsetweaks.mixin.plugin.standard.TargetedMod.REQUIRE_ANY_OPTIFINE;
+import static com.falsepattern.falsetweaks.mixin.plugin.standard.TargetedMod.REQUIRE_OPTIFINE_WITH_DYNAMIC_LIGHTS;
+import static com.falsepattern.falsetweaks.mixin.plugin.standard.TargetedMod.REQUIRE_OPTIFINE_WITH_SHADERS;
 import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.avoid;
 import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.condition;
 import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.require;
@@ -68,10 +71,10 @@ public enum Mixin implements IMixin {
                                   TRIANGULATOR.and(AVOID_ANY_OPTIFINE),
                                   "triangulator.optifine.TessellatorVanillaMixin"),
     Tri_OFTessellatorVanillaOrOldOptifineMixin(Side.CLIENT,
-                                               TRIANGULATOR.and(avoid(TargetedMod.OPTIFINE_WITH_SHADERS)),
+                                               TRIANGULATOR.and(AVOID_OPTIFINE_WITH_SHADERS),
                                                "triangulator.optifine.TessellatorVanillaOrOldOptifineMixin"),
     Tri_OFTessellatorOptiFineMixin(Side.CLIENT,
-                                   TRIANGULATOR.and(require(TargetedMod.OPTIFINE_WITH_SHADERS)),
+                                   TRIANGULATOR.and(REQUIRE_OPTIFINE_WITH_SHADERS),
                                    "triangulator.optifine.TessellatorOptiFineMixin"),
 
     //ChromatiCraft
@@ -128,10 +131,10 @@ public enum Mixin implements IMixin {
 
     //OptiFine with shaders
     Occlusion_Optifine_Shaders_ShadersRendererMixin(Side.CLIENT,
-                                                    OCCLUSION.and(require(TargetedMod.OPTIFINE_WITH_SHADERS)),
+                                                    OCCLUSION.and(REQUIRE_OPTIFINE_WITH_SHADERS),
                                                     "occlusion.optifine.shaders.ShadersRendererMixin"),
     Occlusion_Optifine_Shaders_FrustrumMixin(Side.CLIENT,
-                                             OCCLUSION.and(require(TargetedMod.OPTIFINE_WITH_SHADERS)),
+                                             OCCLUSION.and(REQUIRE_OPTIFINE_WITH_SHADERS),
                                              "occlusion.optifine.shaders.FrustrumMixin"),
 
 
@@ -158,7 +161,7 @@ public enum Mixin implements IMixin {
     ThreadedUpdates_TessellatorMixin_Debug(Side.CLIENT, THREADING, "threadedupdates.TessellatorMixin_Debug"),
     ThreadedUpdates_WorldRendererMixin(Side.CLIENT, THREADING, "threadedupdates.WorldRendererMixin"),
     ThreadedUpdates_Optifine_ShadersMixin(Side.CLIENT,
-                                          THREADING.and(require(TargetedMod.OPTIFINE_WITH_SHADERS)),
+                                          THREADING.and(REQUIRE_OPTIFINE_WITH_SHADERS),
                                           "threadedupdates.optifine.ShadersMixin"),
 
     //DragonAPI
@@ -176,7 +179,8 @@ public enum Mixin implements IMixin {
     ThreadedUpdates_OptiFine_GuiPerformanceSettingsOFMixin(Side.CLIENT,
                                                THREADING.and(REQUIRE_ANY_OPTIFINE),
                                                "threadedupdates.optifine.GuiPerformanceSettingsOFMixin"),
-
+    ThreadedUpdates_OptiFine_WorldClientMixin(Side.CLIENT, THREADING.and(REQUIRE_OPTIFINE_WITH_DYNAMIC_LIGHTS),
+                                                   "threadedupdates.optifine.WorldClientMixin"),
     //endregion Threaded Chunk Updates
 
     //region Texture Optimizations Module

diff --git a/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/TargetedMod.java b/src/main/java/com/falsepattern/falsetweaks/mixin/plugin/standard/TargetedMod.java
@@ -25,6 +25,7 @@
 import java.util.List;
 import java.util.function.Predicate;
 
+import static com.falsepattern.falsetweaks.mixin.plugin.standard.Extras.OPTIFINE_DYNAMIC_LIGHTS_VERSIONS;
 import static com.falsepattern.falsetweaks.mixin.plugin.standard.Extras.OPTIFINE_SHADERSMOD_VERSIONS;
 import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.avoid;
 import static com.falsepattern.lib.mixin.IMixin.PredicateHelpers.require;
@@ -35,8 +36,9 @@ public enum TargetedMod implements ITargetedMod {
     ARCHAICFIX("ArchaicFix", false, startsWith("archaicfix")),
     FOAMFIX("FoamFix", false, startsWith("foamfix")),
     OPTIFINE_WITHOUT_SHADERS("OptiFine without shaders", false,
-                             startsWith("optifine").and(OPTIFINE_SHADERSMOD_VERSIONS.negate())),
+                             startsWith("optifine").and(OPTIFINE_SHADERSMOD_VERSIONS.or(OPTIFINE_DYNAMIC_LIGHTS_VERSIONS).negate())),
     OPTIFINE_WITH_SHADERS("OptiFine with shaders", false, startsWith("optifine").and(OPTIFINE_SHADERSMOD_VERSIONS)),
+    OPTIFINE_WITH_DYNAMIC_LIGHTS("OptiFine with dynamic lights", false, startsWith("optifine").and(OPTIFINE_DYNAMIC_LIGHTS_VERSIONS)),
     FASTCRAFT("FastCraft", false, startsWith("fastcraft")),
     CHROMATICRAFT("ChromatiCraft", false, startsWith("chromaticraft")),
     REDSTONEPASTE("RedstonePaste", false, startsWith("redstonepaste")),
@@ -45,8 +47,12 @@ public enum TargetedMod implements ITargetedMod {
     DRAGONAPI("DragonAPI", false, startsWith("dragonapi")),
     ;
 
-    public static Predicate<List<ITargetedMod>> REQUIRE_ANY_OPTIFINE = require(OPTIFINE_WITH_SHADERS).or(require(OPTIFINE_WITHOUT_SHADERS));
-    public static Predicate<List<ITargetedMod>> AVOID_ANY_OPTIFINE = avoid(OPTIFINE_WITH_SHADERS).and(avoid(OPTIFINE_WITHOUT_SHADERS));
+    public static Predicate<List<ITargetedMod>> REQUIRE_OPTIFINE_WITHOUT_SHADERS = require(OPTIFINE_WITHOUT_SHADERS).or(require(OPTIFINE_WITH_DYNAMIC_LIGHTS));
+    public static Predicate<List<ITargetedMod>> REQUIRE_OPTIFINE_WITH_SHADERS = require(OPTIFINE_WITH_SHADERS);
+    public static Predicate<List<ITargetedMod>> AVOID_OPTIFINE_WITH_SHADERS = avoid(OPTIFINE_WITH_SHADERS);
+    public static Predicate<List<ITargetedMod>> REQUIRE_OPTIFINE_WITH_DYNAMIC_LIGHTS = require(OPTIFINE_WITH_SHADERS).or(require(OPTIFINE_WITH_DYNAMIC_LIGHTS));
+    public static Predicate<List<ITargetedMod>> REQUIRE_ANY_OPTIFINE = require(OPTIFINE_WITH_SHADERS).or(require(OPTIFINE_WITHOUT_SHADERS)).or(require(OPTIFINE_WITH_DYNAMIC_LIGHTS));
+    public static Predicate<List<ITargetedMod>> AVOID_ANY_OPTIFINE = avoid(OPTIFINE_WITH_SHADERS).and(avoid(OPTIFINE_WITHOUT_SHADERS)).and(avoid(OPTIFINE_WITH_DYNAMIC_LIGHTS));
 
     @Getter
     private final String modName;

diff --git a/src/main/java/com/falsepattern/falsetweaks/modules/occlusion/OcclusionCompat.java b/src/main/java/com/falsepattern/falsetweaks/modules/occlusion/OcclusionCompat.java
@@ -31,9 +31,11 @@
 import org.embeddedt.archaicfix.config.ArchaicConfig;
 import shadersmod.client.Shaders;
 import stubpackage.Config;
+import stubpackage.DynamicLights;
 import stubpackage.net.minecraft.client.renderer.EntityRenderer;
 
 import net.minecraft.client.gui.GuiOptionButton;
+import net.minecraft.client.renderer.RenderGlobal;
 import net.minecraft.client.renderer.WorldRenderer;
 import net.minecraft.launchwrapper.Launch;
 import cpw.mods.fml.common.Loader;
@@ -147,6 +149,14 @@ public static boolean disableControl(List addToList, Object control) {
             button.enabled = false;
             return addToList.add(button);
         }
+
+        public static void updateDynamicLights(RenderGlobal rg) {
+            if (!Compat.optiFineHasDynamicLights())
+                return;
+            if (!Config.isDynamicLights())
+                return;
+            DynamicLights.update(rg);
+        }
     }
 
     public static class DragonAPICompat {

diff --git a/src/main/java/com/falsepattern/falsetweaks/modules/occlusion/OcclusionRenderer.java b/src/main/java/com/falsepattern/falsetweaks/modules/occlusion/OcclusionRenderer.java
@@ -618,6 +618,7 @@ private void queryMissingVisgraphs() {
     }
 
     public int sortAndRender(EntityLivingBase view, int pass, double tick) {
+        OcclusionCompat.OptiFineCompat.updateDynamicLights(rg);
         queryMissingVisgraphs();
         CameraInfo cam = CameraInfo.getInstance();
         cam.update(view, tick);

diff --git a/src/main/java/com/falsepattern/falsetweaks/modules/threadedupdates/OptiFineCompat.java b/src/main/java/com/falsepattern/falsetweaks/modules/threadedupdates/OptiFineCompat.java
@@ -19,9 +19,14 @@
 
 import com.falsepattern.falsetweaks.Compat;
 import shadersmod.client.Shaders;
+import stubpackage.ChunkCacheOF;
 import stubpackage.Config;
 
-import cpw.mods.fml.client.FMLClientHandler;
+import net.minecraft.launchwrapper.Launch;
+import net.minecraft.world.ChunkCache;
+import net.minecraft.world.World;
+
+import java.io.IOException;
 
 public class OptiFineCompat {
     public static class ThreadSafeEntityData {
@@ -37,4 +42,32 @@ public static void popEntity() {
         }
         Shaders.popEntity();
     }
+
+    private static Boolean HAS_CHUNKCACHE = null;
+
+    public static ChunkCache createChunkCache(World world, int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, int subIn) {
+        if (HAS_CHUNKCACHE == null) {
+            if (Compat.optiFineInstalled()) {
+                try {
+                    HAS_CHUNKCACHE = Launch.classLoader.getClassBytes("ChunkCacheOF") != null;
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    HAS_CHUNKCACHE = false;
+                }
+            } else {
+                HAS_CHUNKCACHE = false;
+            }
+        }
+        if (HAS_CHUNKCACHE) {
+            return WrappedOF.createOFChunkCache(world, xMin, yMin, zMin, xMax, yMax, zMax, subIn);
+        } else {
+            return new ChunkCache(world, xMin, yMin, zMin, xMax, yMax, zMax, subIn);
+        }
+    }
+
+    private static class WrappedOF {
+        private static ChunkCache createOFChunkCache(World world, int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, int subIn) {
+            return new ChunkCacheOF(world, xMin, yMin, zMin, xMax, yMax, zMax, subIn);
+        }
+    }
 }
diff --git a/.../java/com/falsepattern/falsetweaks/modules/threadedupdates/ThreadedChunkUpdateHelper.java b/.../java/com/falsepattern/falsetweaks/modules/threadedupdates/ThreadedChunkUpdateHelper.java
@@ -362,7 +362,7 @@ public static boolean canBlockBeRenderedOffThread(Block block, int pass, int ren
     private ChunkCache getChunkCacheSnapshot(WorldRenderer wr) {
         // TODO This is not thread-safe! Actually make a snapshot here.
         byte pad = 1;
-        ChunkCache chunkcache = new ChunkCache(wr.worldObj, wr.posX - pad, wr.posY - pad, wr.posZ - pad,
+        ChunkCache chunkcache = OptiFineCompat.createChunkCache(wr.worldObj, wr.posX - pad, wr.posY - pad, wr.posZ - pad,
                 wr.posX + 16 + pad, wr.posY + 16 + pad, wr.posZ + 16 + pad, pad);
         return chunkcache;
     }

diff --git a/src/main/java/stubpackage/ChunkCacheOF.java b/src/main/java/stubpackage/ChunkCacheOF.java
@@ -0,0 +1,10 @@
+package stubpackage;
+
+import net.minecraft.world.ChunkCache;
+import net.minecraft.world.World;
+
+public class ChunkCacheOF extends ChunkCache {
+    public ChunkCacheOF(World p_i1964_1_, int p_i1964_2_, int p_i1964_3_, int p_i1964_4_, int p_i1964_5_, int p_i1964_6_, int p_i1964_7_, int p_i1964_8_) {
+        super(p_i1964_1_, p_i1964_2_, p_i1964_3_, p_i1964_4_, p_i1964_5_, p_i1964_6_, p_i1964_7_, p_i1964_8_);
+    }
+}
diff --git a/src/main/java/stubpackage/Config.java b/src/main/java/stubpackage/Config.java
@@ -34,4 +34,8 @@ public static boolean isShaders() {
     public static boolean isFogOff() {
         return false;
     }
+
+    public static boolean isDynamicLights() {
+        return false;
+    }
 }
diff --git a/src/main/java/stubpackage/DynamicLights.java b/src/main/java/stubpackage/DynamicLights.java
@@ -0,0 +1,9 @@
+package stubpackage;
+
+import net.minecraft.client.renderer.RenderGlobal;
+
+public class DynamicLights {
+    public static void update(RenderGlobal rg) {
+
+    }
+}