asynchronous skull texture loading

RecursiveG · RecursiveG · commit 57a411364961 · 2016-03-22T14:41:28.000-05:00
diff --git a/src/main/java/org/devinprogress/uniskinmod/UniSkinCore.java b/src/main/java/org/devinprogress/uniskinmod/UniSkinCore.java
@@ -23,7 +23,10 @@
 import java.lang.reflect.Field;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.util.Collections;
+import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
 
 /**
@@ -284,21 +287,36 @@ public ResourceLocation getDynamicSkinResource(NetworkPlayerInfo player) {
     /**
      * called from TileEntitySkllRenderer.renderSkull()
      */
+    private final Set<String> loading = Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());
+
     public ResourceLocation getDynamicSkinResourceForSkull(GameProfile gp, ResourceLocation def) {
         if (gp == null) return def;
-        String name = gp.getName();
+        final String name = gp.getName();
         if (name == null || name.length() <= 0) return def;
-        try {
-            DynamicSkinManager.CachedDynamicSkin s = dynamicSkinManager.cache.get(name);
-            if (s.skin != null && s.skin.length != 0) {
-                double spf = (double) s.skinInterval / (double) s.skin.length;
-                int id = ((int) Math.floor((double) (System.currentTimeMillis() % s.skinInterval) / spf)) % (s.skin.length);
-                return s.skin[id];
-            }
-        } catch (ExecutionException ex) {
-            UniSkinMod.log.catching(Level.WARN, ex);
+
+        if (loading.contains(name)) return def;
+        DynamicSkinManager.CachedDynamicSkin s = dynamicSkinManager.cache.getIfPresent(name);
+        if (s == null) {
+            loading.add(name);
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        dynamicSkinManager.cache.get(name);
+                    } catch (ExecutionException ex) {
+                        UniSkinMod.log.catching(Level.WARN, ex);
+                    }
+                    loading.remove(name);
+                }
+            }, "Skull-Texture-Fetch-" + name).start();
             return def;
         }
+        if (s.skin != null && s.skin.length != 0) {
+            double spf = (double) s.skinInterval / (double) s.skin.length;
+            int id = ((int) Math.floor((double) (System.currentTimeMillis() % s.skinInterval) / spf)) % (s.skin.length);
+            return s.skin[id];
+        }
+
         return def;
     }
 
diff --git a/src/main/java/org/devinprogress/uniskinmod/UniSkinMod.java b/src/main/java/org/devinprogress/uniskinmod/UniSkinMod.java
@@ -13,9 +13,13 @@
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.Logger;
 import org.devinprogress.uniskinmod.coremod.IGetTexture_old;
+import org.devinprogress.uniskinmod.coremod.ILoadSkinFromCache_old;
 
 import java.io.File;
+import java.util.Collections;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
 
 @Mod(modid = "uniskinmod")
@@ -85,4 +89,26 @@ public static ResourceLocation getDynamicCapeResource(NetworkPlayerInfo player)
     public static ResourceLocation getDynamicElytraResource(NetworkPlayerInfo player) {
         return instance.core == null ? null : instance.core.getDynamicElytraResource(player);
     }
+
+
+    private static final Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> defaultReturn = Collections.emptyMap();
+    private static final Set<GameProfile> onLoading = Collections.newSetFromMap(new ConcurrentHashMap<GameProfile, Boolean>());
+
+    public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadSkinFromCache_wrapper(final GameProfile gp, final ILoadSkinFromCache_old skinManager) {
+        if (onLoading.contains(gp)) return defaultReturn;
+        Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> ret = skinManager.getLoadingCache().getIfPresent(gp);
+        if (ret == null) {
+            onLoading.add(gp);
+            String name = gp.getName() == null ? gp.toString() : gp.getName();
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    skinManager.getLoadingCache().getUnchecked(gp);
+                    onLoading.remove(gp);
+                }
+            }, "Skin-Fetch-" + name).start();
+            return defaultReturn;
+        }
+        return ret;
+    }
 }
diff --git a/src/main/java/org/devinprogress/uniskinmod/coremod/AsmTransformer.java b/src/main/java/org/devinprogress/uniskinmod/coremod/AsmTransformer.java
@@ -229,4 +229,59 @@ public void transform(ClassNode cn, String classObfName, MethodNode mn, String s
             mn.instructions.insertBefore(n, new VarInsnNode(Opcodes.ASTORE, 11));
         }
     }
+
+    /*
+     * Make SkinManager.cache load textures asynchronously
+    @RegisterTransformer(
+            className = "net.minecraft.client.resources.SkinManager",
+            mcpName = "<init>",
+            desc = "(Lnet/minecraft/client/renderer/texture/TextureManager;Ljava/io/File;Lcom/mojang/authlib/minecraft/MinecraftSessionService;)V"
+
+    )
+    public static class delayedLoadingCacheTransformaer implements IMethodTransformer {
+        @Override
+        public void transform(ClassNode cn, String classObfName, MethodNode mn, String srgName, boolean devEnv) {
+            AbstractInsnNode n = getNthInsnNode(mn, Opcodes.PUTFIELD, 4);
+            mn.instructions.insertBefore(n, new MethodInsnNode(Opcodes.INVOKESTATIC, "org/devinprogress/uniskinmod/coremod/DelayedLoadingCache",
+                    "wrap", "(Lcom/google/common/cache/LoadingCache;)Lcom/google/common/cache/LoadingCache;", false));
+        }
+    }
+    */
+
+    /**
+     * Make SkinManager.loadSkinFromCache(), which is used by skull
+     * texture loading, loads textures asynchronously.
+     * Thus avoids main thread freezing.
+     */
+    @RegisterTransformer(
+            className = "net.minecraft.client.resources.SkinManager",
+            mcpName = "loadSkinFromCache",
+            srgName = "func_152788_a",
+            desc = "(Lcom/mojang/authlib/GameProfile;)Ljava/util/Map;"
+    )
+    public static class asyncLoadingCacheTransformer implements IMethodTransformer {
+        @Override
+        public void transform(ClassNode cn, String classObfName, MethodNode mn, String srgName, boolean devEnv) {
+            MethodNode wrapperMethod = new MethodNode(mn.access, mn.name, mn.desc, null,
+                    mn.exceptions.toArray(new String[mn.exceptions.size()]));
+            mn.name = "loadSkinFromCache_old";
+            mn.access = Opcodes.ACC_PUBLIC;
+
+            wrapperMethod.instructions.add(new VarInsnNode(Opcodes.ALOAD, 1));
+            wrapperMethod.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+            wrapperMethod.instructions.add(new MethodInsnNode(Opcodes.INVOKESTATIC, INVOKE_TARGET_CLASS, "loadSkinFromCache_wrapper",
+                    "(Lcom/mojang/authlib/GameProfile;Lorg/devinprogress/uniskinmod/coremod/ILoadSkinFromCache_old;)Ljava/util/Map;", false));
+            wrapperMethod.instructions.add(new InsnNode(Opcodes.ARETURN));
+            wrapperMethod.maxStack = 3;
+
+            cn.methods.add(wrapperMethod);
+            cn.interfaces.add(ILoadSkinFromCache_old.class.getName().replace(".", "/"));
+
+            MethodNode getCacheMethod = new MethodNode(Opcodes.ACC_PUBLIC, "getLoadingCache", "()Lcom/google/common/cache/LoadingCache;", null, new String[0]);
+            getCacheMethod.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
+            getCacheMethod.instructions.add(getNthInsnNode(mn, Opcodes.GETFIELD, 1).clone(Collections.<LabelNode, LabelNode>emptyMap()));
+            getCacheMethod.instructions.add(new InsnNode(Opcodes.ARETURN));
+            cn.methods.add(getCacheMethod);
+        }
+    }
 }
diff --git a/src/main/java/org/devinprogress/uniskinmod/coremod/DelayedLoadingCache.java b/src/main/java/org/devinprogress/uniskinmod/coremod/DelayedLoadingCache.java
@@ -0,0 +1,55 @@
+package org.devinprogress.uniskinmod.coremod;
+
+import com.google.common.cache.ForwardingLoadingCache;
+import com.google.common.cache.LoadingCache;
+import com.google.common.util.concurrent.UncheckedExecutionException;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftProfileTexture;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+
+public class DelayedLoadingCache extends ForwardingLoadingCache.SimpleForwardingLoadingCache<GameProfile, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> {
+    public static LoadingCache<GameProfile, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> wrap(LoadingCache<GameProfile, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> inside) {
+        return new DelayedLoadingCache(inside);
+    }
+
+    private DelayedLoadingCache(LoadingCache<GameProfile, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> inside) {
+        super(inside);
+    }
+
+    private final Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> defaultReturn = Collections.emptyMap();
+    private Set<GameProfile> onLoading = Collections.newSetFromMap(new ConcurrentHashMap<GameProfile, Boolean>());
+
+    @Override
+    public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> get(GameProfile key) throws ExecutionException {
+        final GameProfile gp = key;
+        if (onLoading.contains(key)) return defaultReturn;
+        Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> ret = super.getIfPresent(gp);
+        if (ret == null) {
+            onLoading.add(gp);
+            String name = gp.getName() == null ? gp.toString() : gp.getName();
+            new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    DelayedLoadingCache.super.getUnchecked(gp);
+                    onLoading.remove(gp);
+                }
+            }, "Skin-Fetch-" + name).start();
+            return defaultReturn;
+        }
+        return ret;
+    }
+
+    @Override
+    public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getUnchecked(GameProfile key) {
+        try {
+            return get(key);
+        } catch (ExecutionException ex) {
+            throw new UncheckedExecutionException(ex);
+        }
+    }
+}
diff --git a/src/main/java/org/devinprogress/uniskinmod/coremod/ILoadSkinFromCache_old.java b/src/main/java/org/devinprogress/uniskinmod/coremod/ILoadSkinFromCache_old.java
@@ -0,0 +1,13 @@
+package org.devinprogress.uniskinmod.coremod;
+
+import com.google.common.cache.LoadingCache;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftProfileTexture;
+
+import java.util.Map;
+
+public interface ILoadSkinFromCache_old {
+    Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadSkinFromCache_old(GameProfile profile);
+
+    LoadingCache<GameProfile, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> getLoadingCache();
+}
