Add Forge 1.20.1 HD 3D Skin Layers compatibility

forge/build.gradle

@@ -11,6 +11,7 @@ loom {
     forge {
         convertAccessWideners = true
         mixinConfig "skinsg.mixins.json"
+        mixinConfig "skinsg.skinlayers3d.mixins.json"
     }
 }
 
@@ -25,6 +26,8 @@ configurations {
 dependencies {
     forge "net.minecraftforge:forge:${rootProject.forge_version}"
     modApi "dev.architectury:architectury-forge:${rootProject.architectury_api_version}"
+    modCompileOnly "maven.modrinth:3dskinlayers:BBnR3V86"
+    modLocalRuntime "maven.modrinth:3dskinlayers:BBnR3V86"
 
     common(project(path: ":common", configuration: "namedElements")) { transitive false }
     shadowBundle project(path: ":common", configuration: "transformProductionForge")

forge/src/main/java/xyz/nightsync/skinsg/forge/compat/skinlayers3d/SkinLayersCompatPlugin.java

@@ -0,0 +1,21 @@
+package xyz.nightsync.skinsg.forge.compat.skinlayers3d;
+
+import org.objectweb.asm.tree.ClassNode;
+import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
+import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+
+import java.util.List;
+import java.util.Set;
+
+public final class SkinLayersCompatPlugin implements IMixinConfigPlugin {
+    @Override public void onLoad(String mixinPackage) {}
+    @Override public String getRefMapperConfig() { return null; }
+    @Override public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {
+        return SkinLayersCompatPlugin.class.getClassLoader()
+                .getResource("dev/tr7zw/skinlayers/SkinUtil.class") != null;
+    }
+    @Override public void acceptTargets(Set<String> myTargets, Set<String> otherTargets) {}
+    @Override public List<String> getMixins() { return null; }
+    @Override public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {}
+    @Override public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) {}
+}

forge/src/main/java/xyz/nightsync/skinsg/forge/compat/skinlayers3d/mixin/SkinUtilMixin.java

@@ -0,0 +1,183 @@
+package xyz.nightsync.skinsg.forge.compat.skinlayers3d.mixin;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftProfileTexture;
+import dev.tr7zw.skinlayers.SkinUtil;
+import dev.tr7zw.skinlayers.accessor.PlayerSettings;
+import dev.tr7zw.skinlayers.accessor.SkullSettings;
+import dev.tr7zw.skinlayers.api.Mesh;
+import dev.tr7zw.skinlayers.api.MeshHelper;
+import dev.tr7zw.skinlayers.api.SkinLayersAPI;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.ResourceLocation;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.Map;
+
+@Mixin(value = SkinUtil.class, remap = false)
+public abstract class SkinUtilMixin {
+    private static final Logger LOGGER = LoggerFactory.getLogger("skinsg");
+    private static final int MAX_HD_SIZE = 2048;
+    private static final long LOG_COOLDOWN_MS = 60_000L;
+    private static final ConcurrentHashMap<String, Long> LAST_LOG = new ConcurrentHashMap<>();
+
+    @Inject(method = "setup3dLayers", at = @At("HEAD"), cancellable = true, require = 0)
+    private static void skinsg$setupPlayer(AbstractClientPlayer player, PlayerSettings settings, boolean thinArms,
+                                           CallbackInfoReturnable<Boolean> cir) {
+        ResourceLocation location = player.getSkinTextureLocation();
+        NativeImage skin = SkinUtil.getTexture(location, null);
+        if (!isHdSkin(skin)) return;
+
+        if (location.equals(settings.getCurrentSkin()) && thinArms == settings.hasThinArms()) {
+            cir.setReturnValue(settings.getHeadMesh() != null);
+            return;
+        }
+        try (NativeImage meshMap = downsampleForMesh(skin)) {
+            buildPlayerMeshes(meshMap, settings, thinArms);
+            settings.setCurrentSkin(location);
+            settings.setThinArms(thinArms);
+            cir.setReturnValue(true);
+        } catch (Exception | LinkageError error) {
+            settings.clearMeshes();
+            settings.setCurrentSkin(location);
+            settings.setThinArms(thinArms);
+            logFailure("PLAYER_MESH", location, skin, error);
+            cir.setReturnValue(buildFallbackPlayer(settings, thinArms));
+        }
+    }
+
+    @Inject(method = "setup3dLayers", at = @At("HEAD"), cancellable = true, require = 0)
+    private static void skinsg$setupSkull(GameProfile profile, SkullSettings settings,
+                                          CallbackInfoReturnable<Boolean> cir) {
+        if (profile == null) return;
+        Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> textures = Minecraft.getInstance()
+                .getSkinManager().getInsecureSkinInformation(profile);
+        MinecraftProfileTexture texture = textures.get(MinecraftProfileTexture.Type.SKIN);
+        if (texture == null) return;
+        ResourceLocation location = Minecraft.getInstance().getSkinManager()
+                .registerTexture(texture, MinecraftProfileTexture.Type.SKIN);
+        setupSkull(location, settings, cir);
+    }
+
+    @Inject(method = "setup3dLayers", at = @At("HEAD"), cancellable = true, require = 0)
+    private static void skinsg$setupSkull(ResourceLocation location, SkullSettings settings,
+                                          CallbackInfoReturnable<Boolean> cir) {
+        setupSkull(location, settings, cir);
+    }
+
+    private static void setupSkull(ResourceLocation location, SkullSettings settings,
+                                   CallbackInfoReturnable<Boolean> cir) {
+        NativeImage skin = SkinUtil.getTexture(location, settings);
+        if (!isHdSkin(skin)) return;
+        try (NativeImage meshMap = downsampleForMesh(skin)) {
+            settings.setupHeadLayers(meshHelper().create3DMesh(meshMap, 8, 8, 8, 32, 0, false, 0.6f));
+            settings.setInitialized(true);
+            cir.setReturnValue(true);
+        } catch (Exception | LinkageError error) {
+            settings.setupHeadLayers(null);
+            settings.setInitialized(true);
+            logFailure("SKULL_MESH", location, skin, error);
+            cir.setReturnValue(buildFallbackSkull(settings));
+        }
+    }
+
+    private static boolean isHdSkin(NativeImage image) {
+        if (image == null) return false;
+        int width = image.getWidth();
+        return width > 64 && width <= MAX_HD_SIZE && image.getHeight() == width
+                && width % 64 == 0 && (width & (width - 1)) == 0;
+    }
+
+    private static NativeImage downsampleForMesh(NativeImage source) {
+        NativeImage result = new NativeImage(64, 64, true);
+        int scale = source.getWidth() / 64;
+        try {
+            for (int y = 0; y < 64; y++) {
+                for (int x = 0; x < 64; x++) {
+                    int selected = 0;
+                    int highestAlpha = -1;
+                    for (int sy = 0; sy < scale; sy++) {
+                        for (int sx = 0; sx < scale; sx++) {
+                            int pixel = source.getPixelRGBA(x * scale + sx, y * scale + sy);
+                            int alpha = pixel >>> 24;
+                            if (alpha > highestAlpha) {
+                                highestAlpha = alpha;
+                                selected = pixel;
+                            }
+                        }
+                    }
+                    result.setPixelRGBA(x, y, selected);
+                }
+            }
+            return result;
+        } catch (RuntimeException error) {
+            result.close();
+            throw error;
+        }
+    }
+
+    private static void buildPlayerMeshes(NativeImage skin, PlayerSettings settings, boolean thinArms) {
+        MeshHelper helper = meshHelper();
+        settings.clearMeshes();
+        settings.setLeftLegMesh(helper.create3DMesh(skin, 4, 12, 4, 0, 48, true, 0f));
+        settings.setRightLegMesh(helper.create3DMesh(skin, 4, 12, 4, 0, 32, true, 0f));
+        int armWidth = thinArms ? 3 : 4;
+        settings.setLeftArmMesh(helper.create3DMesh(skin, armWidth, 12, 4, 48, 48, true, -2f));
+        settings.setRightArmMesh(helper.create3DMesh(skin, armWidth, 12, 4, 40, 32, true, -2f));
+        settings.setTorsoMesh(helper.create3DMesh(skin, 8, 12, 4, 16, 32, true, 0f));
+        settings.setHeadMesh(helper.create3DMesh(skin, 8, 8, 8, 32, 0, false, 0.6f));
+    }
+
+    private static boolean buildFallbackPlayer(PlayerSettings settings, boolean thinArms) {
+        try (NativeImage fallback = opaqueMeshMap()) {
+            buildPlayerMeshes(fallback, settings, thinArms);
+            return settings.getHeadMesh() != null;
+        } catch (Exception | LinkageError error) {
+            settings.clearMeshes();
+            logFailure("PLAYER_FALLBACK", settings.getCurrentSkin(), null, error);
+            return false;
+        }
+    }
+
+    private static boolean buildFallbackSkull(SkullSettings settings) {
+        try (NativeImage fallback = opaqueMeshMap()) {
+            Mesh mesh = meshHelper().create3DMesh(fallback, 8, 8, 8, 32, 0, false, 0.6f);
+            settings.setupHeadLayers(mesh);
+            return mesh != null;
+        } catch (Exception | LinkageError error) {
+            settings.setupHeadLayers(null);
+            logFailure("SKULL_FALLBACK", settings.getLastTexture(), null, error);
+            return false;
+        }
+    }
+
+    private static NativeImage opaqueMeshMap() {
+        NativeImage image = new NativeImage(64, 64, true);
+        image.fillRect(0, 0, 64, 64, 0xFFFFFFFF);
+        return image;
+    }
+
+    private static MeshHelper meshHelper() {
+        return SkinLayersAPI.getMeshHelper();
+    }
+
+    private static void logFailure(String stage, ResourceLocation resource, NativeImage image, Throwable error) {
+        String key = stage + '|' + resource + '|' + error.getClass().getName();
+        long now = System.currentTimeMillis();
+        Long previous = LAST_LOG.put(key, now);
+        if (previous == null || now - previous >= LOG_COOLDOWN_MS) {
+            String dimensions = image == null ? "unknown" : image.getWidth() + "x" + image.getHeight();
+            LOGGER.error("[SkinsG/3DSL Compat] HD skin processing failed; using safe fallback. "
+                            + "stage={}, resource={}, dimensions={}, thread={}",
+                    stage, resource, dimensions, Thread.currentThread().getName(), error);
+        }
+    }
+}

forge/src/main/resources/skinsg.skinlayers3d.mixins.json

@@ -0,0 +1,9 @@
+{
+  "required": false,
+  "minVersion": "0.8",
+  "compatibilityLevel": "JAVA_17",
+  "package": "xyz.nightsync.skinsg.forge.compat.skinlayers3d.mixin",
+  "plugin": "xyz.nightsync.skinsg.forge.compat.skinlayers3d.SkinLayersCompatPlugin",
+  "client": ["SkinUtilMixin"],
+  "injectors": { "defaultRequire": 0 }
+}