From 5830503dfce07eb272a58754f3d748ba77415107 Mon Sep 17 00:00:00 2001 From: ZekerZhayard Date: Thu, 1 Oct 2026 08:30:39 +0800 Subject: [PATCH] refactor: rebuild ASM transformation framework and support 26.3 (#399) --- .github/actions/build/action.yml | 2 +- .github/workflows/beta.yml | 6 +- .github/workflows/pull-request.yml | 2 +- .github/workflows/release.yml | 11 +- .../ClassTransformationContext.java | 4 - .../ClassTransformationReport.java | 41 +- .../transformer/ClassTransformerRegistry.java | 51 -- .../RuntimeClassTransformerEngine.java | 46 -- .../bootstrap/transformer/RuntimeVersion.java | 24 + .../transformer/TargetedClassTransformer.java | 46 -- .../transformer/TransformationObserver.java | 9 + .../transformer/TransformationPlan.java | 175 +++++++ .../transformer/TransformationRule.java | 84 +++ .../TransformationRuleProvider.java | 7 + .../TransformerBootstrapSupport.java | 140 ++--- .../transformer/VersionSelector.java | 20 + .../transformer/patch/FrameCapture.java | 97 ++++ .../transformer/patch/InterfacePatch.java | 53 +- .../transformer/patch/PatchSupport.java | 142 +++-- .../transformer/patch/RenderPatch.java | 176 +++---- .../transformer/patch/SkinManagerPatch.java | 484 +++++++----------- .../transformer/patch/SkinTexturePatch.java | 212 +++----- ...ap.transformer.TransformationRuleProvider} | 0 .../fabric/v1/MixinConfigPlugin.java | 9 +- .../fabric/v1/TransformerBootstrap.java | 213 +++----- .../forge/v1/TransformerBootstrap.java | 12 +- .../forge/v2/TransformationService.java | 6 +- .../forge/v2/TransformerBootstrap.java | 82 ++- .../v2/ClassProcessorProviderImpl.java | 2 +- .../neoforge/v2/TransformerBootstrap.java | 74 ++- .../customskinloader/fake/FakeSkinBuffer.java | 18 +- .../fake/FakeSkinManager.java | 31 +- .../loader/GameProfileLoader.java | 7 +- .../loader/MojangAPILoader.java | 15 +- .../customskinloader/utils/TextureUtil.java | 15 +- build.info.json | 4 +- gradle.properties | 6 +- gradle/wrapper/gradle-wrapper.jar | Bin 48462 -> 47505 bytes gradle/wrapper/gradle-wrapper.properties | 2 +- gradlew | 4 +- gradlew.bat | 4 +- 41 files changed, 1118 insertions(+), 1218 deletions(-) delete mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformerRegistry.java delete mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeClassTransformerEngine.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeVersion.java delete mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TargetedClassTransformer.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationObserver.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationPlan.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRule.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRuleProvider.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/VersionSelector.java create mode 100644 Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/FrameCapture.java rename Bootstrap/Core/src/main/resources/META-INF/services/{customskinloader.bootstrap.transformer.TargetedClassTransformer => customskinloader.bootstrap.transformer.TransformationRuleProvider} (100%) diff --git a/.github/actions/build/action.yml b/.github/actions/build/action.yml index 4cb8dcb..52638a7 100644 --- a/.github/actions/build/action.yml +++ b/.github/actions/build/action.yml @@ -30,7 +30,7 @@ outputs: runs: using: composite steps: - - uses: actions/setup-java@v5 + - uses: actions/setup-java@v6 with: distribution: temurin java-version: '25' diff --git a/.github/workflows/beta.yml b/.github/workflows/beta.yml index 1fd7e00..05cfe77 100644 --- a/.github/workflows/beta.yml +++ b/.github/workflows/beta.yml @@ -11,7 +11,7 @@ jobs: name: Build runs-on: windows-latest steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: ./.github/actions/build with: @@ -22,7 +22,7 @@ jobs: needs: build runs-on: windows-latest steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: actions/download-artifact@v8 with: @@ -54,7 +54,7 @@ jobs: runs-on: windows-latest environment: Build steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: actions/download-artifact@v8 with: diff --git a/.github/workflows/pull-request.yml b/.github/workflows/pull-request.yml index 7ed5445..3339592 100644 --- a/.github/workflows/pull-request.yml +++ b/.github/workflows/pull-request.yml @@ -9,7 +9,7 @@ jobs: name: Build runs-on: windows-latest steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: ./.github/actions/build with: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 2b95755..10180e2 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -18,7 +18,7 @@ jobs: game_versions: ${{ steps.build.outputs.game_versions }} java: ${{ steps.build.outputs.java }} steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: ./.github/actions/build id: build @@ -30,7 +30,7 @@ jobs: needs: build runs-on: windows-latest steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: actions/download-artifact@v8 with: @@ -51,7 +51,7 @@ jobs: runs-on: windows-latest environment: Build steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: actions/download-artifact@v8 with: @@ -85,14 +85,14 @@ jobs: runs-on: windows-latest environment: Build steps: - - uses: actions/checkout@v6 + - uses: actions/checkout@v7 - uses: actions/download-artifact@v8 with: name: CustomSkinLoader-Release-${{ github.run_number }} path: artifact - - uses: Kir-Antipov/mc-publish@v3.3 + - uses: Kir-Antipov/mc-publish@v3 with: modrinth-id: idMHQ4n2 modrinth-featured: true @@ -107,6 +107,7 @@ jobs: ${{ needs.build.outputs.loaders }} game-versions: | ${{ needs.build.outputs.game_versions }} + environment: client game-version-filter: releases java: | ${{ needs.build.outputs.java }} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationContext.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationContext.java index 9f24555..3f09c5e 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationContext.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationContext.java @@ -68,10 +68,6 @@ public final class ClassTransformationContext { return this.mappings.unmapMethodDescriptor(targetDescriptor); } - public boolean isTarget(String canonicalName) { - return this.getInternalClassName().equals(this.remapClassName(canonicalName)); - } - public MethodNode findMethod(String owner, String name, String desc) { String mappedDesc = this.remapMethodDescriptor(desc); String mappedName = "".equals(name) ? name : this.remapMethodName(owner, name, desc); diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationReport.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationReport.java index eb23ba2..9b1dc85 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationReport.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformationReport.java @@ -7,40 +7,41 @@ import java.util.List; import org.objectweb.asm.tree.ClassNode; public final class ClassTransformationReport { - private final ClassTransformationContext context; - private final List appliedTransformerNames; + private final String internalClassName; + private final ClassNode transformedClassNode; + private final byte[] originalBytecode; + private final List appliedRuleNames; private volatile byte[] transformedBytecode; - public ClassTransformationReport(ClassTransformationContext context, List appliedTransformerNames) { - this.context = context; - this.appliedTransformerNames = Collections.unmodifiableList(new ArrayList<>(appliedTransformerNames)); - } - - public ClassTransformationContext getContext() { - return this.context; + ClassTransformationReport(String internalClassName, ClassNode transformedClassNode, byte[] originalBytecode, List appliedRuleNames) { + this.internalClassName = internalClassName; + this.transformedClassNode = transformedClassNode; + this.originalBytecode = originalBytecode; + this.appliedRuleNames = Collections.unmodifiableList(new ArrayList<>(appliedRuleNames)); } public byte[] getTransformedBytecode() { - if (this.transformedBytecode == null) { - if (this.getTransformedClassNode() == null) { - throw new IllegalStateException("Transformed bytecode is not available without a transformed ClassNode"); - } - - this.transformedBytecode = TransformerBootstrapSupport.toByteArray(this.getTransformedClassNode()); + if (!this.isModified() && this.originalBytecode != null) { + return this.originalBytecode.clone(); + } + if (this.transformedBytecode == null) { + if (this.transformedClassNode == null) { + throw new IllegalStateException("Transformed bytecode is not available without a ClassNode"); + } + this.transformedBytecode = TransformerBootstrapSupport.toByteArray(this.transformedClassNode); } - return this.transformedBytecode.clone(); } public ClassNode getTransformedClassNode() { - return this.context.getCurrentClassNode(); + return this.transformedClassNode; } - public List getAppliedTransformerNames() { - return this.appliedTransformerNames; + public List getAppliedRuleNames() { + return this.appliedRuleNames; } public boolean isModified() { - return !this.appliedTransformerNames.isEmpty(); + return !this.appliedRuleNames.isEmpty(); } } diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformerRegistry.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformerRegistry.java deleted file mode 100644 index aab3a60..0000000 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/ClassTransformerRegistry.java +++ /dev/null @@ -1,51 +0,0 @@ -package customskinloader.bootstrap.transformer; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.Comparator; -import java.util.List; -import java.util.concurrent.CopyOnWriteArrayList; - -import customskinloader.bootstrap.mapping.Mappings; - -public final class ClassTransformerRegistry { - private static final Comparator TRANSFORMER_ORDER = (left, right) -> { - // Higher-priority transformers run first so low-priority patches can react to earlier changes. - int priorityOrder = Integer.compare(right.getPriority(), left.getPriority()); - if (priorityOrder != 0) { - return priorityOrder; - } - - return left.getName().compareTo(right.getName()); - }; - - private final CopyOnWriteArrayList transformers = new CopyOnWriteArrayList<>(); - - public void register(TargetedClassTransformer transformer) { - this.transformers.add(transformer); - this.sortTransformers(); - } - - public List getTransformers() { - return Collections.unmodifiableList(new ArrayList<>(this.transformers)); - } - - public List getApplicableTransformers(String className, Mappings mappings) { - List applicableTransformers = new ArrayList<>(); - - for (TargetedClassTransformer transformer : this.transformers) { - if (transformer.supports(className, mappings)) { - applicableTransformers.add(transformer); - } - } - - return Collections.unmodifiableList(applicableTransformers); - } - - private void sortTransformers() { - List sortedTransformers = new ArrayList<>(this.transformers); - Collections.sort(sortedTransformers, TRANSFORMER_ORDER); - this.transformers.clear(); - this.transformers.addAll(sortedTransformers); - } -} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeClassTransformerEngine.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeClassTransformerEngine.java deleted file mode 100644 index 12205d4..0000000 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeClassTransformerEngine.java +++ /dev/null @@ -1,46 +0,0 @@ -package customskinloader.bootstrap.transformer; - -import java.util.ArrayList; -import java.util.List; - -import customskinloader.bootstrap.BootstrapLogger; -import org.apache.logging.log4j.Logger; - -public final class RuntimeClassTransformerEngine { - private static final Logger LOGGER = BootstrapLogger.LOGGER; - - private final ClassTransformerRegistry registry; - - public RuntimeClassTransformerEngine(ClassTransformerRegistry registry) { - this.registry = registry; - } - - public ClassTransformationReport transform(ClassTransformationContext context) { - List appliedTransformers = new ArrayList<>(); - - for (TargetedClassTransformer transformer : this.registry.getApplicableTransformers(context.getInternalClassName(), context.getMappings())) { - if (!this.applyTransformer(transformer, context)) { - LOGGER.debug("Skipped transformer " + transformer.getName() + " for " + context.getInternalClassName()); - continue; - } - appliedTransformers.add(transformer.getName()); - LOGGER.debug("Applied transformer " + transformer.getName() + " to " + context.getInternalClassName()); - } - - if (!appliedTransformers.isEmpty()) { - LOGGER.info("Transformed " + context.getInternalClassName() + " with " + appliedTransformers); - } - - return new ClassTransformationReport(context, appliedTransformers); - } - - private boolean applyTransformer(TargetedClassTransformer transformer, ClassTransformationContext context) { - try { - return transformer.transform(context); - } catch (Exception exception) { - String message = "Failed to transform " + context.getInternalClassName() + " with " + transformer.getName(); - LOGGER.error(message, exception); - throw new IllegalStateException(message, exception); - } - } -} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeVersion.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeVersion.java new file mode 100644 index 0000000..e9916b5 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/RuntimeVersion.java @@ -0,0 +1,24 @@ +package customskinloader.bootstrap.transformer; + +public final class RuntimeVersion { + private final int protocolVersion; + private final int worldVersion; + + public RuntimeVersion(int protocolVersion, int worldVersion) { + this.protocolVersion = protocolVersion; + this.worldVersion = worldVersion; + } + + public int getProtocolVersion() { + return this.protocolVersion; + } + + public int getWorldVersion() { + return this.worldVersion; + } + + @Override + public String toString() { + return "protocol=" + this.protocolVersion + ", world=" + this.worldVersion; + } +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TargetedClassTransformer.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TargetedClassTransformer.java deleted file mode 100644 index 9411b4b..0000000 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TargetedClassTransformer.java +++ /dev/null @@ -1,46 +0,0 @@ -package customskinloader.bootstrap.transformer; - -import java.util.Arrays; -import java.util.Collections; -import java.util.LinkedHashSet; -import java.util.Set; - -public abstract class TargetedClassTransformer { - private final String name; - private final int priority; - private final Set targetClassNames; - - protected TargetedClassTransformer(String name, int priority, String... targetClassNames) { - this.name = name; - this.priority = priority; - this.targetClassNames = Collections.unmodifiableSet(new LinkedHashSet<>(Arrays.asList(targetClassNames))); - } - - public final String getName() { - return this.name; - } - - public final int getPriority() { - return this.priority; - } - - public boolean supports(String className, customskinloader.bootstrap.mapping.Mappings mappings) { - if (this.targetClassNames.isEmpty()) { - return false; - } - - for (String targetClassName : this.targetClassNames) { - if (className.equals(mappings.remapClassName(targetClassName))) { - return true; - } - } - - return false; - } - - public Set getTargetClassNames() { - return this.targetClassNames; - } - - public abstract boolean transform(ClassTransformationContext context) throws Exception; -} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationObserver.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationObserver.java new file mode 100644 index 0000000..18f7e53 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationObserver.java @@ -0,0 +1,9 @@ +package customskinloader.bootstrap.transformer; + +public interface TransformationObserver { + void ruleApplied(String ruleId, String internalClassName); + + void optionalRuleSkipped(String message); + + void classTransformed(String internalClassName, Iterable ruleIds); +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationPlan.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationPlan.java new file mode 100644 index 0000000..8dd76b5 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationPlan.java @@ -0,0 +1,175 @@ +package customskinloader.bootstrap.transformer; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import customskinloader.bootstrap.mapping.Mappings; +import org.objectweb.asm.ClassReader; +import org.objectweb.asm.tree.ClassNode; + +public final class TransformationPlan { + private static final String IGNORE_PATCH_FAILURE_PROPERTY = "customskinloader.ignorePatchFailure"; + private static final Comparator RULE_ORDER = (left, right) -> { + // Higher-priority transformers run first so low-priority patches can react to earlier changes. + int priorityOrder = Integer.compare(right.getPriority(), left.getPriority()); + if (priorityOrder != 0) { + return priorityOrder; + } + int groupOrder = left.getGroupName().compareTo(right.getGroupName()); + if (groupOrder != 0) { + return groupOrder; + } + int declarationOrder = Integer.compare(left.getDeclarationOrder(), right.getDeclarationOrder()); + return declarationOrder != 0 ? declarationOrder : left.getId().compareTo(right.getId()); + }; + + private final RuntimeVersion runtimeVersion; + private final Mappings mappings; + private final TransformationObserver observer; + private final Map> rulesByTargetClass; + private final Set targetClassNames; + private final int declaredRuleCount; + private final int activeRuleCount; + + public TransformationPlan(Iterable providers, RuntimeVersion runtimeVersion, Mappings mappings, TransformationObserver observer) { + if (providers == null || runtimeVersion == null || mappings == null || observer == null) { + throw new IllegalArgumentException("Transformation plan inputs must not be null"); + } + + this.runtimeVersion = runtimeVersion; + this.mappings = mappings; + this.observer = observer; + + Map> mutableRulesByTarget = new LinkedHashMap<>(); + Set ruleIds = new HashSet<>(); + Set activeVariants = new HashSet<>(); + int declaredRules = 0; + int activeRules = 0; + for (TransformationRuleProvider provider : providers) { + if (provider == null) { + throw new IllegalStateException("Transformation rule provider must not be null"); + } + + List rules = provider.getTransformationRules(); + if (rules == null) { + throw new IllegalStateException("Transformation rule provider " + provider.getClass().getName() + " returned null"); + } + for (TransformationRule rule : rules) { + declaredRules++; + if (rule == null) { + throw new IllegalStateException("Transformation rule provider " + provider.getClass().getName() + " returned a null rule"); + } + if (!ruleIds.add(rule.getId())) { + throw new IllegalStateException("Duplicate transformation rule id: " + rule.getId()); + } + if (!rule.getVersionSelector().matches(runtimeVersion)) { + continue; + } + + String mappedTargetClassName = mappings.remapClassName(rule.getTargetClassName()).replace('.', '/'); + if (rule.getVariantGroup() != null && !activeVariants.add(mappedTargetClassName + "@" + rule.getVariantGroup())) { + throw new IllegalStateException("Multiple variants from transformation rule group " + rule.getVariantGroup() + + " are active for " + mappedTargetClassName + " at " + runtimeVersion); + } + mutableRulesByTarget.computeIfAbsent(mappedTargetClassName, ignored -> new ArrayList<>()).add(rule); + activeRules++; + } + } + + Map> compiledRulesByTarget = new LinkedHashMap<>(); + for (Map.Entry> entry : mutableRulesByTarget.entrySet()) { + List sortedRules = new ArrayList<>(entry.getValue()); + Collections.sort(sortedRules, RULE_ORDER); + compiledRulesByTarget.put(entry.getKey(), Collections.unmodifiableList(sortedRules)); + } + + this.rulesByTargetClass = Collections.unmodifiableMap(compiledRulesByTarget); + this.targetClassNames = Collections.unmodifiableSet(new LinkedHashSet<>(compiledRulesByTarget.keySet())); + this.declaredRuleCount = declaredRules; + this.activeRuleCount = activeRules; + } + + public Set getTargetClassNames() { + return this.targetClassNames; + } + + public int getDeclaredRuleCount() { + return this.declaredRuleCount; + } + + public int getActiveRuleCount() { + return this.activeRuleCount; + } + + public ClassTransformationReport transform(String className, byte[] classBytecode) { + if (classBytecode == null) { + throw new IllegalArgumentException("Class bytecode must not be null"); + } + + String internalClassName = className == null ? "" : className.replace('.', '/'); + List rules = this.rulesByTargetClass.get(internalClassName); + if (rules == null) { + return new ClassTransformationReport(internalClassName, null, classBytecode, Collections.emptyList()); + } + + ClassNode classNode = new ClassNode(); + // Expanded frames are required to derive the stack map frames of inserted branch targets + // without loading any class (see FrameCapture). The writer compresses them again. + new ClassReader(classBytecode).accept(classNode, ClassReader.EXPAND_FRAMES); + return this.transform(internalClassName, classNode, classBytecode, rules); + } + + public ClassTransformationReport transform(String className, ClassNode classNode) { + if (classNode == null) { + throw new IllegalArgumentException("Class node must not be null"); + } + + String internalClassName = className == null || className.trim().isEmpty() ? classNode.name : className.replace('.', '/'); + List rules = this.rulesByTargetClass.get(internalClassName); + if (rules == null) { + return new ClassTransformationReport(internalClassName, classNode, null, Collections.emptyList()); + } + return this.transform(internalClassName, classNode, null, rules); + } + + private ClassTransformationReport transform(String internalClassName, ClassNode classNode, byte[] originalBytecode, List rules) { + ClassTransformationContext context = ClassTransformationContext.create(internalClassName, classNode, this.mappings); + List appliedRules = new ArrayList<>(); + for (TransformationRule rule : rules) { + boolean modified; + try { + modified = rule.getOperation().apply(context); + } catch (Exception exception) { + String message = "Failed to apply transformation rule " + rule.getId() + " to " + internalClassName; + throw new IllegalStateException(message, exception); + } + + if (!modified) { + String message = "Transformation rule '" + rule.getId() + "' selected " + internalClassName + " for " + + this.runtimeVersion + " but did not modify any bytecode. If you want to force CustomSkinLoader to ignore this patch failure, add -D" + + IGNORE_PATCH_FAILURE_PROPERTY + "=true to the JVM arguments."; + String failureSetting = System.getProperty(IGNORE_PATCH_FAILURE_PROPERTY); + if ("false".equalsIgnoreCase(failureSetting) || (rule.isRequired() && !Boolean.getBoolean(IGNORE_PATCH_FAILURE_PROPERTY))) { + throw new IllegalStateException(message); + } + this.observer.optionalRuleSkipped(message); + continue; + } + + appliedRules.add(rule.getId()); + this.observer.ruleApplied(rule.getId(), internalClassName); + } + + if (!appliedRules.isEmpty()) { + this.observer.classTransformed(internalClassName, appliedRules); + } + return new ClassTransformationReport(internalClassName, classNode, originalBytecode, appliedRules); + } +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRule.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRule.java new file mode 100644 index 0000000..2ba652a --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRule.java @@ -0,0 +1,84 @@ +package customskinloader.bootstrap.transformer; + +public final class TransformationRule { + @FunctionalInterface + public interface Operation { + boolean apply(ClassTransformationContext context) throws Exception; + } + + private final String groupName; + private final String name; + private final int priority; + private final int declarationOrder; + private final String variantGroup; + private final String targetClassName; + private final VersionSelector versionSelector; + private final boolean required; + private final Operation operation; + + public TransformationRule(String groupName, String name, int priority, int declarationOrder, String targetClassName, String versionExpression, boolean required, Operation operation) { + if (groupName == null || groupName.trim().isEmpty()) { + throw new IllegalArgumentException("Transformation rule group name must not be empty"); + } + if (name == null || name.trim().isEmpty()) { + throw new IllegalArgumentException("Transformation rule name must not be empty"); + } + if (targetClassName == null || targetClassName.trim().isEmpty()) { + throw new IllegalArgumentException("Transformation rule target class must not be empty"); + } + if (operation == null) { + throw new IllegalArgumentException("Transformation rule operation must not be null"); + } + + this.groupName = groupName; + this.name = name; + this.priority = priority; + this.declarationOrder = declarationOrder; + int variantMarker = name.lastIndexOf(".v"); + boolean numberedVariant = variantMarker > 0 && variantMarker + 2 < name.length(); + for (int index = variantMarker + 2; numberedVariant && index < name.length(); index++) { + numberedVariant = Character.isDigit(name.charAt(index)); + } + this.variantGroup = numberedVariant ? groupName + "/" + name.substring(0, variantMarker) : null; + this.targetClassName = targetClassName.replace('.', '/'); + this.versionSelector = new VersionSelector(versionExpression); + this.required = required; + this.operation = operation; + } + + public String getId() { + return this.groupName + "/" + this.name; + } + + public int getPriority() { + return this.priority; + } + + public String getGroupName() { + return this.groupName; + } + + public int getDeclarationOrder() { + return this.declarationOrder; + } + + public String getVariantGroup() { + return this.variantGroup; + } + + public String getTargetClassName() { + return this.targetClassName; + } + + public VersionSelector getVersionSelector() { + return this.versionSelector; + } + + public boolean isRequired() { + return this.required; + } + + public Operation getOperation() { + return this.operation; + } +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRuleProvider.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRuleProvider.java new file mode 100644 index 0000000..d35d722 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformationRuleProvider.java @@ -0,0 +1,7 @@ +package customskinloader.bootstrap.transformer; + +import java.util.List; + +public interface TransformationRuleProvider { + List getTransformationRules(); +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformerBootstrapSupport.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformerBootstrapSupport.java index 2c5d2a9..085fa1b 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformerBootstrapSupport.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/TransformerBootstrapSupport.java @@ -1,111 +1,85 @@ package customskinloader.bootstrap.transformer; -import java.lang.reflect.Field; -import java.lang.reflect.Modifier; -import java.util.Collections; -import java.util.LinkedHashSet; import java.util.ServiceLoader; import java.util.Set; import customskinloader.bootstrap.BootstrapLogger; import customskinloader.bootstrap.mapping.Loader; import customskinloader.bootstrap.mapping.Mappings; +import customskinloader.bootstrap.mapping.VersionMetadataReader; import org.apache.logging.log4j.Logger; -import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.tree.ClassNode; public final class TransformerBootstrapSupport { - private static final Field[] CLASS_NODE_FIELDS = ClassNode.class.getFields(); private static final Logger LOGGER = BootstrapLogger.LOGGER; private final Object lock = new Object(); private final Class serviceLoaderAnchor; private final String mappingType; - private final ClassTransformerRegistry registry = new ClassTransformerRegistry(); - private final RuntimeClassTransformerEngine transformerEngine = new RuntimeClassTransformerEngine(this.registry); - - private volatile boolean transformersLoaded; - private volatile Mappings mappings; + private volatile TransformationPlan transformationPlan; public TransformerBootstrapSupport(Class serviceLoaderAnchor, String mappingType) { if (serviceLoaderAnchor == null) { throw new IllegalArgumentException("Service loader anchor must not be null"); } - this.serviceLoaderAnchor = serviceLoaderAnchor; this.mappingType = mappingType; } - public void ensureTransformersLoaded() { - if (this.transformersLoaded) { - return; + public Set getTargetClassNames() { + return this.getTransformationPlan().getTargetClassNames(); + } + + public ClassTransformationReport transform(String internalClassName, byte[] classBytecode) { + return this.getTransformationPlan().transform(internalClassName, classBytecode); + } + + public ClassTransformationReport transform(String internalClassName, ClassNode inputClassNode) { + return this.getTransformationPlan().transform(internalClassName, inputClassNode); + } + + private TransformationPlan getTransformationPlan() { + TransformationPlan loadedPlan = this.transformationPlan; + if (loadedPlan != null) { + return loadedPlan; } synchronized (this.lock) { - if (this.transformersLoaded) { - return; - } + loadedPlan = this.transformationPlan; + if (loadedPlan == null) { + LOGGER.info("Compiling CustomSkinLoader transformation plan for " + this.mappingType + " mappings"); + Mappings mappings = Loader.load(this.serviceLoaderAnchor.getClassLoader(), this.mappingType); + // Discover platform-contributed targeted transformers lazily through the shared service contract. + ServiceLoader providers = ServiceLoader.load( + TransformationRuleProvider.class, this.serviceLoaderAnchor.getClassLoader()); + loadedPlan = new TransformationPlan( + providers, + new RuntimeVersion(VersionMetadataReader.PROTOCOL_VERSION, VersionMetadataReader.WORLD_VERSION), + mappings, + new TransformationObserver() { + @Override + public void ruleApplied(String ruleId, String internalClassName) { + LOGGER.debug("Applied transformation rule " + ruleId + " to " + internalClassName); + } - // Discover platform-contributed targeted transformers lazily through the shared service contract. - ServiceLoader serviceLoader = ServiceLoader.load(TargetedClassTransformer.class, this.serviceLoaderAnchor.getClassLoader()); - int transformerCount = 0; - for (TargetedClassTransformer transformer : serviceLoader) { - this.registry.register(transformer); - transformerCount++; - LOGGER.debug("Registered transformer " + transformer.getName() - + " with priority " + transformer.getPriority() - + " and targets " + transformer.getTargetClassNames()); - } + @Override + public void optionalRuleSkipped(String message) { + LOGGER.warn(message); + } - this.transformersLoaded = true; - LOGGER.info("Loaded " + transformerCount + " CustomSkinLoader bootstrap transformer(s) for " + this.mappingType + " mappings"); - } - } - - public Set collectTargetClassNames() { - this.ensureTransformersLoaded(); - Mappings loadedMappings = this.getMappings(); - - Set targetClassNames = new LinkedHashSet<>(); - for (TargetedClassTransformer transformer : this.registry.getTransformers()) { - for (String targetClassName : transformer.getTargetClassNames()) { - targetClassNames.add(loadedMappings.remapClassName(targetClassName)); + @Override + public void classTransformed(String internalClassName, Iterable ruleIds) { + LOGGER.info("Transformed " + internalClassName + " with " + ruleIds); + } + } + ); + this.transformationPlan = loadedPlan; + LOGGER.info("Compiled " + loadedPlan.getActiveRuleCount() + " of " + loadedPlan.getDeclaredRuleCount() + + " transformation rule(s) for " + loadedPlan.getTargetClassNames().size() + " target class(es)"); } } - - LOGGER.info("Collected " + targetClassNames.size() + " CustomSkinLoader bootstrap target class(es) for " + this.mappingType + " mappings"); - return Collections.unmodifiableSet(targetClassNames); - } - - public boolean hasApplicableTransformers(String internalClassName) { - this.ensureTransformersLoaded(); - return !this.registry.getApplicableTransformers(internalClassName, this.getMappings()).isEmpty(); - } - - public ClassTransformationReport transformClassNode(String internalClassName, ClassNode inputClassNode) { - this.ensureTransformersLoaded(); - ClassTransformationContext context = ClassTransformationContext.create(internalClassName, inputClassNode, this.getMappings()); - return this.transformerEngine.transform(context); - } - - public Mappings getMappings() { - Mappings loadedMappings = this.mappings; - if (loadedMappings != null) { - return loadedMappings; - } - - synchronized (this.lock) { - loadedMappings = this.mappings; - if (loadedMappings == null) { - LOGGER.info("Loading CustomSkinLoader bootstrap mappings for " + this.mappingType); - loadedMappings = Loader.load(this.serviceLoaderAnchor.getClassLoader(), this.mappingType); - this.mappings = loadedMappings; - LOGGER.info("Loaded " + loadedMappings.getClassMappings().size() + " CustomSkinLoader bootstrap class mapping(s) for " + this.mappingType); - } - } - - return loadedMappings; + return loadedPlan; } public static byte[] toByteArray(ClassNode classNode) { @@ -114,22 +88,4 @@ public final class TransformerBootstrapSupport { return classWriter.toByteArray(); } - public static ClassNode toClassNode(byte[] classBytecode) { - ClassReader classReader = new ClassReader(classBytecode); - ClassNode classNode = new ClassNode(); - classReader.accept(classNode, 0); - return classNode; - } - - public static void copyClassNode(ClassNode source, ClassNode target) { - try { - for (Field field : CLASS_NODE_FIELDS) { - if (!Modifier.isStatic(field.getModifiers())) { - field.set(target, field.get(source)); - } - } - } catch (IllegalAccessException exception) { - throw new IllegalStateException("Failed to copy transformed ClassNode state", exception); - } - } } diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/VersionSelector.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/VersionSelector.java new file mode 100644 index 0000000..2d60b08 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/VersionSelector.java @@ -0,0 +1,20 @@ +package customskinloader.bootstrap.transformer; + +import customskinloader.bootstrap.util.RangeMatcher; + +public final class VersionSelector { + private final String expression; + + public VersionSelector(String expression) { + this.expression = expression == null ? "" : expression.trim(); + } + + public boolean matches(RuntimeVersion version) { + return RangeMatcher.matches(this.expression, version.getProtocolVersion(), version.getWorldVersion()); + } + + @Override + public String toString() { + return this.expression.isEmpty() ? "*" : this.expression; + } +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/FrameCapture.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/FrameCapture.java new file mode 100644 index 0000000..284aea0 --- /dev/null +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/FrameCapture.java @@ -0,0 +1,97 @@ +package customskinloader.bootstrap.transformer.patch; + +import java.util.ArrayList; +import java.util.List; + +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.commons.AnalyzerAdapter; +import org.objectweb.asm.tree.AbstractInsnNode; +import org.objectweb.asm.tree.FrameNode; +import org.objectweb.asm.tree.MethodNode; + +/** + * Computes the operand stack / local variable state around a given instruction without loading any + * class. Only usable when the method already carries expanded (F_NEW) stack map frames, which is + * the case for the byte array based transformation paths. Platforms that recompute frames (e.g. + * ModLauncher) hand over compressed frames; callers must then fall back to letting the platform + * compute the frames. + */ +final class FrameCapture { + final Object[] localsBefore; + final Object[] stackBefore; + final Object[] localsAfter; + final Object[] stackAfter; + + private FrameCapture(Object[] localsBefore, Object[] stackBefore, Object[] localsAfter, Object[] stackAfter) { + this.localsBefore = localsBefore; + this.stackBefore = stackBefore; + this.localsAfter = localsAfter; + this.stackAfter = stackAfter; + } + + static FrameCapture capture(String owner, MethodNode methodNode, AbstractInsnNode target) { + if (!hasExpandedFrames(methodNode)) { + return null; + } + + AnalyzerAdapter analyzer = new AnalyzerAdapter(owner, methodNode.access, methodNode.name, methodNode.desc, null); + for (AbstractInsnNode instruction = methodNode.instructions.getFirst(); instruction != null; instruction = instruction.getNext()) { + if (instruction == target) { + Object[] localsBefore = toFrameTypes(analyzer.locals); + Object[] stackBefore = toFrameTypes(analyzer.stack); + if (localsBefore == null || stackBefore == null) { + return null; + } + + instruction.accept(analyzer); + + Object[] localsAfter = toFrameTypes(analyzer.locals); + Object[] stackAfter = toFrameTypes(analyzer.stack); + if (localsAfter == null || stackAfter == null) { + return null; + } + + return new FrameCapture(localsBefore, stackBefore, localsAfter, stackAfter); + } + + instruction.accept(analyzer); + } + return null; + } + + private static boolean hasExpandedFrames(MethodNode methodNode) { + for (AbstractInsnNode instruction : methodNode.instructions) { + if (instruction instanceof FrameNode && ((FrameNode) instruction).type != Opcodes.F_NEW) { + return false; + } + } + return true; + } + + /** + * Converts the slot based lists maintained by {@link AnalyzerAdapter} into the expanded frame + * format expected by {@link FrameNode}. Long and double values occupy two slots but only one + * frame entry, so the implicit {@code TOP} following them must be dropped. + */ + private static Object[] toFrameTypes(List slots) { + if (slots == null) { + return null; + } + + List types = new ArrayList<>(slots.size()); + for (int index = 0; index < slots.size(); index++) { + Object slot = slots.get(index); + if (!(slot instanceof String) && !(slot instanceof Integer)) { + // Uninitialized types are represented by analyzer owned labels that cannot be mapped + // back to labels of the method being transformed. + return null; + } + + types.add(slot); + if (slot instanceof Integer && (slot.equals(Opcodes.LONG) || slot.equals(Opcodes.DOUBLE))) { + index++; + } + } + return types.toArray(); + } +} diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/InterfacePatch.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/InterfacePatch.java index 9276719..a240367 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/InterfacePatch.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/InterfacePatch.java @@ -1,47 +1,24 @@ package customskinloader.bootstrap.transformer.patch; -import customskinloader.bootstrap.transformer.ClassTransformationContext; - public final class InterfacePatch extends PatchSupport { public InterfacePatch() { - super( - "customskinloader:interface-patch", 1000, - targets( - HTTP_TEXTURE_PROCESSOR, "[,553]", // 19w37a- (1.14.4-) - RESOURCE, "", - RESOURCE_MANAGER, "", - NATIVE_IMAGE, "[404,]", // 1.13.2+ - IDENTIFIER, "" - ) - ); - } + super("customskinloader:interface-patch", 1000); - @Override - public boolean transform(ClassTransformationContext context) { - boolean modified = false; + // 19w37a- (1.14.4-) + this.rule("http-texture-processor.interface", HTTP_TEXTURE_PROCESSOR, "[,553]", context -> + this.addInterface(context.getCurrentClassNode(), FAKE_HTTP_TEXTURE_PROCESSOR)); - if (context.isTarget(HTTP_TEXTURE_PROCESSOR)) { - modified |= this.requireModified("http-texture-processor.interface", this.addInterface(context.getCurrentClassNode(), FAKE_HTTP_TEXTURE_PROCESSOR)); - } - if (context.isTarget(RESOURCE)) { - boolean resourceModified = false; - resourceModified |= this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_V1); - resourceModified |= this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_V2); - modified |= this.requireModified("resource.interfaces", resourceModified); - } - if (context.isTarget(RESOURCE_MANAGER)) { - boolean resourceManagerModified = false; - resourceManagerModified |= this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_MANAGER_V1); - resourceManagerModified |= this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_MANAGER_V2); - modified |= this.requireModified("resource-manager.interfaces", resourceManagerModified); - } - if (context.isTarget(NATIVE_IMAGE)) { - modified |= this.requireModified("native-image.interface", this.addInterface(context.getCurrentClassNode(), FAKE_NATIVE_IMAGE)); - } - if (context.isTarget(IDENTIFIER)) { - modified |= this.requireModified("identifier.patch", this.makeMethodPublicNonFinal(context.findMethod(IDENTIFIER, "", "(" + objectDesc(STRING) + objectDesc(STRING) + ")V"))); - } + this.rule("resource.interfaces", RESOURCE, "", context -> + this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_V1) | this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_V2)); - return modified; + this.rule("resource-manager.interfaces", RESOURCE_MANAGER, "", context -> + this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_MANAGER_V1) | this.addInterface(context.getCurrentClassNode(), FAKE_I_RESOURCE_MANAGER_V2)); + + // 1.13.2+ + this.rule("native-image.interface", NATIVE_IMAGE, "[404,]", context -> + this.addInterface(context.getCurrentClassNode(), FAKE_NATIVE_IMAGE)); + + this.rule("identifier.constructor", IDENTIFIER, "", context -> + this.makeMethodPublicNonFinal(context.findMethod(IDENTIFIER, "", "(" + objectDesc(STRING) + objectDesc(STRING) + ")V"))); } } diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/PatchSupport.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/PatchSupport.java index bebc854..647727c 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/PatchSupport.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/PatchSupport.java @@ -2,31 +2,31 @@ package customskinloader.bootstrap.transformer.patch; import java.util.ArrayList; import java.util.Collections; -import java.util.LinkedHashMap; import java.util.List; -import java.util.Map; -import java.util.function.BooleanSupplier; import customskinloader.bootstrap.BootstrapLogger; -import customskinloader.bootstrap.mapping.VersionMetadataReader; -import customskinloader.bootstrap.transformer.TargetedClassTransformer; -import customskinloader.bootstrap.util.RangeMatcher; -import org.apache.logging.log4j.Logger; +import customskinloader.bootstrap.transformer.ClassTransformationContext; +import customskinloader.bootstrap.transformer.TransformationRule; +import customskinloader.bootstrap.transformer.TransformationRuleProvider; import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; +import org.objectweb.asm.tree.FrameNode; import org.objectweb.asm.tree.InnerClassNode; import org.objectweb.asm.tree.InsnList; +import org.objectweb.asm.tree.InsnNode; +import org.objectweb.asm.tree.JumpInsnNode; +import org.objectweb.asm.tree.LabelNode; +import org.objectweb.asm.tree.LdcInsnNode; import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.TypeInsnNode; -abstract class PatchSupport extends TargetedClassTransformer implements Opcodes { - private static final String IGNORE_PATCH_FAILURE_PROPERTY = "customskinloader.ignorePatchFailure"; - private static final Logger LOGGER = BootstrapLogger.LOGGER; +abstract class PatchSupport implements TransformationRuleProvider, Opcodes { protected static final String BOOLEAN = "java/lang/Boolean"; protected static final String OBJECT = "java/lang/Object"; + protected static final String RUNNABLE = "java/lang/Runnable"; protected static final String STRING = "java/lang/String"; protected static final String CALL_SITE = "java/lang/invoke/CallSite"; protected static final String LAMBDA_METAFACTORY = "java/lang/invoke/LambdaMetafactory"; @@ -36,8 +36,8 @@ abstract class PatchSupport extends TargetedClassTransformer implements Opcodes protected static final String FILE = "java/io/File"; protected static final String INPUT_STREAM = "java/io/InputStream"; protected static final String PATH = "java/nio/file/Path"; - protected static final String RUNNABLE = "java/lang/Runnable"; protected static final String MAP = "java/util/Map"; + protected static final String OBJECTS = "java/util/Objects"; protected static final String UUID = "java/util/UUID"; protected static final String COMPLETABLE_FUTURE = "java/util/concurrent/CompletableFuture"; protected static final String EXECUTOR = "java/util/concurrent/Executor"; @@ -101,6 +101,7 @@ abstract class PatchSupport extends TargetedClassTransformer implements Opcodes protected static final String MINECRAFT_PROFILE_TEXTURE_TYPE = "com/mojang/authlib/minecraft/MinecraftProfileTexture$Type"; protected static final String MINECRAFT_SESSION_SERVICE = "com/mojang/authlib/minecraft/MinecraftSessionService"; protected static final String MINECRAFT_PROFILE_TEXTURES = "com/mojang/authlib/minecraft/MinecraftProfileTextures"; + protected static final String SESSION_SERVICE = "com/mojang/authlib/minecraft/SessionService"; protected static final String GAME_PROFILE = "com/mojang/authlib/GameProfile"; protected static final String PROPERTY = "com/mojang/authlib/properties/Property"; @@ -108,39 +109,26 @@ abstract class PatchSupport extends TargetedClassTransformer implements Opcodes return "L" + internalName + ";"; } - private final int protocolVersion; - private final int worldVersion; + private final String groupName; + private final int priority; + private final List rules = new ArrayList<>(); - protected PatchSupport(String name, int priority, Map targetClassNames) { - this(name, priority, VersionMetadataReader.PROTOCOL_VERSION, VersionMetadataReader.WORLD_VERSION, targetClassNames); + protected PatchSupport(String groupName, int priority) { + this.groupName = groupName; + this.priority = priority; } - private PatchSupport(String name, int priority, int protocolVersion, int worldVersion, Map targetClassNames) { - super(name, priority, filterTargetClassNames(targetClassNames, protocolVersion, worldVersion)); - this.protocolVersion = protocolVersion; - this.worldVersion = worldVersion; + protected final void rule(String name, String targetClassName, String versionExpression, TransformationRule.Operation operation) { + this.rules.add(new TransformationRule(this.groupName, name, this.priority, this.rules.size(), targetClassName, versionExpression, true, operation)); } - protected static Map targets(String... targetClassNameProtocolRanges) { - if (targetClassNameProtocolRanges.length % 2 != 0) { - throw new IllegalArgumentException("Target class names must be paired with protocol ranges"); - } - - Map targets = new LinkedHashMap<>(); - for (int index = 0; index < targetClassNameProtocolRanges.length; index += 2) { - targets.put(targetClassNameProtocolRanges[index], targetClassNameProtocolRanges[index + 1]); - } - return Collections.unmodifiableMap(targets); + protected final void optionalRule(String name, String targetClassName, String versionExpression, TransformationRule.Operation operation) { + this.rules.add(new TransformationRule(this.groupName, name, this.priority, this.rules.size(), targetClassName, versionExpression, false, operation)); } - private static String[] filterTargetClassNames(Map targetClassNames, int protocolVersion, int worldVersion) { - List filteredTargetClassNames = new ArrayList<>(); - for (Map.Entry entry : targetClassNames.entrySet()) { - if (RangeMatcher.matches(entry.getValue(), protocolVersion, worldVersion)) { - filteredTargetClassNames.add(entry.getKey()); - } - } - return filteredTargetClassNames.toArray(new String[0]); + @Override + public final List getTransformationRules() { + return Collections.unmodifiableList(new ArrayList<>(this.rules)); } protected boolean addInterface(ClassNode classNode, String interfaceName) { @@ -194,46 +182,6 @@ abstract class PatchSupport extends TargetedClassTransformer implements Opcodes return (access & ~(ACC_PRIVATE | ACC_PROTECTED | ACC_FINAL)) | ACC_PUBLIC; } - protected boolean matches(String range) { - return RangeMatcher.matches(range, this.protocolVersion, this.worldVersion); - } - - protected boolean applyIfMatches(String range, String label, BooleanSupplier operation) { - return applyIfMatches(range, label, operation, true); - } - - protected boolean applyIfMatches(String range, String label, BooleanSupplier operation, boolean required) { - if (!this.matches(range)) { - return false; - } - - return this.requireModified(label, operation.getAsBoolean(), required); - } - - protected boolean requireModified(String label, boolean modified) { - return this.requireModified(label, modified, true); - } - - protected boolean requireModified(String label, boolean modified, boolean required) { - if (modified) { - return true; - } - - String message = "Patch '" + this.getName() + ":" + label + "' matched protocol " + this.protocolVersion - + " but did not modify any bytecode. If you want to force CustomSkinLoader to ignore this patch failure, add -D" - + IGNORE_PATCH_FAILURE_PROPERTY + "=true to the JVM arguments."; - if ("false".equalsIgnoreCase(System.getProperty(IGNORE_PATCH_FAILURE_PROPERTY))) { - throw new IllegalStateException(message); - } - - if (!required || Boolean.getBoolean(IGNORE_PATCH_FAILURE_PROPERTY)) { - LOGGER.warn(message); - return false; - } - - throw new IllegalStateException(message); - } - protected InsnList clone(InsnList source) { InsnList copy = new InsnList(); for (AbstractInsnNode abstractInsnNode : source) { @@ -261,7 +209,43 @@ abstract class PatchSupport extends TargetedClassTransformer implements Opcodes return current; } - protected static void methodNodeSet(MethodNode methodNode, AbstractInsnNode oldInstruction, AbstractInsnNode newInstruction) { - methodNode.instructions.set(oldInstruction, newInstruction); + protected void replaceInstructionSafely(ClassTransformationContext context, MethodNode methodNode, AbstractInsnNode original, AbstractInsnNode replacement) { + this.replaceInstructionSafely(context, methodNode, new InsnNode(ICONST_1), IFNE, original, replacement); + } + + protected void replaceInstructionSafely(ClassTransformationContext context, MethodNode methodNode, AbstractInsnNode condition, int jumpOpcode, AbstractInsnNode original, AbstractInsnNode replacement) { + LabelNode label0 = new LabelNode(); + LabelNode label1 = new LabelNode(); + + InsnList before = new InsnList(); + before.add(condition); + before.add(new JumpInsnNode(jumpOpcode, label0)); + before.add(new LdcInsnNode("Modified by CustomSkinLoader.")); + before.add(new InsnNode(POP)); + + methodNode.instructions.insertBefore(original, before); + + // The original instruction is kept as dead code so later Mixin / coremod transformations + // can still locate it. Both branch targets therefore need a real stack map frame: the + // replacement starts with the state the original instruction would have seen, and the + // merge point continues with the state the original instruction would have produced. + FrameCapture frames = FrameCapture.capture(context.getInternalClassName(), methodNode, original); + if (frames == null) { + BootstrapLogger.LOGGER.debug("Could not derive stack map frames for " + methodNode.name + methodNode.desc + "; the inserted branch targets carry no frame"); + } + + InsnList after = new InsnList(); + after.add(new JumpInsnNode(GOTO, label1)); + after.add(label0); + if (frames != null) { + after.add(new FrameNode(F_NEW, frames.localsBefore.length, frames.localsBefore, frames.stackBefore.length, frames.stackBefore)); + } + after.add(replacement); + after.add(label1); + if (frames != null) { + after.add(new FrameNode(F_NEW, frames.localsAfter.length, frames.localsAfter, frames.stackAfter.length, frames.stackAfter)); + } + + methodNode.instructions.insert(original, after); } } diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/RenderPatch.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/RenderPatch.java index ae370da..8d05d40 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/RenderPatch.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/RenderPatch.java @@ -2,66 +2,78 @@ package customskinloader.bootstrap.transformer.patch; import customskinloader.bootstrap.transformer.ClassTransformationContext; import org.objectweb.asm.tree.AbstractInsnNode; -import org.objectweb.asm.tree.InsnList; -import org.objectweb.asm.tree.InsnNode; import org.objectweb.asm.tree.MethodInsnNode; import org.objectweb.asm.tree.MethodNode; public final class RenderPatch extends PatchSupport { public RenderPatch() { - super( - "customskinloader:render-patch", 1000, - targets( - PLAYER_TAB_OVERLAY, "", - CAPE_LAYER, "[556,]", // 19w39a+ (1.15+) - PLAYER_RENDERER, "[556,767],[801,803],[0x40000001,0x400000CC]" // 19w39a ~ 1.21.1 (1.15 ~ 1.21.1) - ) - ); - } + super("customskinloader:render-patch", 1000); - @Override - public boolean transform(ClassTransformationContext context) { - boolean modified = false; - - if (context.isTarget(PLAYER_TAB_OVERLAY)) { - modified |= this.requireModified("player-tab-overlay", this.patchPlayerTabOverlay(context)); - } - if (context.isTarget(CAPE_LAYER)) { - modified |= this.requireModified("cape-layer", this.patchCapeLayer(context), false); - } - if (context.isTarget(PLAYER_RENDERER)) { - modified |= this.requireModified("player-renderer", this.patchPlayerRenderer(context), false); - } - - return modified; - } - - private boolean patchPlayerTabOverlay(ClassTransformationContext context) { - boolean modified = false; // 20w16a- (1.15.2-) - modified |= this.applyIfMatches("[,712]", "player-tab-overlay.render.v1", () -> replaceMinecraftLocalServerCheck( - context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), MINECRAFT, "isLocalServer" - )); + this.rule("player-tab-overlay.render.v1", PLAYER_TAB_OVERLAY, "[,712]", context -> + this.replaceLocalServerCheck( + context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), + MINECRAFT, "isLocalServer")); // 20w17a ~ 23w14a (1.16 ~ 1.19.4) - modified |= this.applyIfMatches("[713,762],[801,803],[0x40000001,0x40000082]", "player-tab-overlay.render.v2", () -> replaceMinecraftLocalServerCheck( - context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(" + objectDesc(POSE_STACK) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), MINECRAFT, "isLocalServer" - )); + this.rule("player-tab-overlay.render.v2", PLAYER_TAB_OVERLAY, "[713,762],[801,803],[0x40000001,0x40000082]", context -> + this.replaceLocalServerCheck( + context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(" + objectDesc(POSE_STACK) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), + MINECRAFT, "isLocalServer")); // 23w16a ~ 26.1-snapshot-11 (1.20 ~ 1.21.11) - modified |= this.applyIfMatches("[763,774],[0x40000083,0x40000129]", "player-tab-overlay.render.v3", () -> replaceMinecraftLocalServerCheck( - context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(" + objectDesc(GUI_GRAPHICS) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), MINECRAFT, "isLocalServer" - )); + this.rule("player-tab-overlay.render.v3", PLAYER_TAB_OVERLAY, "[763,774],[0x40000083,0x40000129]", context -> + this.replaceLocalServerCheck( + context, context.findMethod(PLAYER_TAB_OVERLAY, "render", "(" + objectDesc(GUI_GRAPHICS) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), + MINECRAFT, "isLocalServer")); // 26.1-pre-1 ~ 26.2-snapshot-6 (26.1 ~ 26.1.2) - modified |= this.applyIfMatches("775,[0x4000012A,0x40000138]", "player-tab-overlay.extract-render-state.v1", () -> replaceMinecraftLocalServerCheck( - context, context.findMethod(PLAYER_TAB_OVERLAY, "extractRenderState", "(" + objectDesc(GUI_GRAPHICS_EXTRACTOR) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), MINECRAFT, "isLocalServer" - )); + this.rule("player-tab-overlay.extract-render-state.v1", PLAYER_TAB_OVERLAY, "775,[0x4000012A,0x40000138]", context -> + this.replaceLocalServerCheck( + context, context.findMethod(PLAYER_TAB_OVERLAY, "extractRenderState", "(" + objectDesc(GUI_GRAPHICS_EXTRACTOR) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), + MINECRAFT, "isLocalServer")); // 26.2-snapshot-7+ (26.2+) - modified |= this.applyIfMatches("[776,800],[804,0x40000000],[0x40000139,]", "player-tab-overlay.extract-render-state.v2", () -> replaceMinecraftLocalServerCheck( - context, context.findMethod(PLAYER_TAB_OVERLAY, "extractRenderState", "(" + objectDesc(GUI_GRAPHICS_EXTRACTOR) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), CLIENT_PACKET_LISTENER, "onlineMode" - )); - return modified; + this.rule("player-tab-overlay.extract-render-state.v2", PLAYER_TAB_OVERLAY, "[776,800],[804,0x40000000],[0x40000139,]", context -> + this.replaceLocalServerCheck( + context, context.findMethod(PLAYER_TAB_OVERLAY, "extractRenderState", "(" + objectDesc(GUI_GRAPHICS_EXTRACTOR) + "I" + objectDesc(SCOREBOARD) + objectDesc(OBJECTIVE) + ")V"), + CLIENT_PACKET_LISTENER, "onlineMode")); + + // 19w39a ~ 19w44a + this.optionalRule("cape-layer.render.v1", CAPE_LAYER, "[556,560]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + "FFFFFFF)V"), + RENDER_TYPE)); + // 19w45a ~ 1.21.1 (1.15 ~ 1.21.1) + this.optionalRule("cape-layer.render.v2", CAPE_LAYER, "[561,767],[801,803],[0x40000001,0x400000CC]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + "FFFFFF)V"), + RENDER_TYPE)); + // 24w33a ~ 1.21.8 (1.21.2 ~ 1.21.8) + this.optionalRule("cape-layer.render.v3", CAPE_LAYER, "[768,772],[0x400000CD,0x40000103]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(PLAYER_RENDER_STATE) + "FF)V"), + RENDER_TYPE)); + // 25w31a ~ 25w42a (1.21.9 ~ 1.21.10) + this.optionalRule("cape-layer.submit.v1", CAPE_LAYER, "773,[0x40000104,0x40000112]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(CAPE_LAYER, "submit", "(" + objectDesc(POSE_STACK) + objectDesc(SUBMIT_NODE_COLLECTOR) + "I" + objectDesc(AVATAR_RENDER_STATE) + "FF)V"), + RENDER_TYPE)); + // 25w43a+ (1.21.11+) + this.optionalRule("cape-layer.submit.v2", CAPE_LAYER, "[774,800],[804,0x40000000],[0x40000113,]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(CAPE_LAYER, "submit", "(" + objectDesc(POSE_STACK) + objectDesc(SUBMIT_NODE_COLLECTOR) + "I" + objectDesc(AVATAR_RENDER_STATE) + "FF)V"), + RENDER_TYPES)); + + // 19w39a ~ 19w44a + this.optionalRule("player-renderer.render-hand.v1", PLAYER_RENDERER, "[556,560]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(PLAYER_RENDERER, "renderHand", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + objectDesc(ABSTRACT_CLIENT_PLAYER) + objectDesc(MODEL_PART) + objectDesc(MODEL_PART) + ")V"), + RENDER_TYPE)); + // 19w45a ~ 1.21.1 (1.15 ~ 1.21.1) + this.optionalRule("player-renderer.render-hand.v2", PLAYER_RENDERER, "[561,767],[801,803],[0x40000001,0x400000CC]", context -> + this.replaceEntitySolidWithTranslucent( + context, context.findMethod(PLAYER_RENDERER, "renderHand", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + objectDesc(MODEL_PART) + objectDesc(MODEL_PART) + ")V"), + RENDER_TYPE)); } - private boolean replaceMinecraftLocalServerCheck(ClassTransformationContext context, MethodNode methodNode, String owner, String name) { + private boolean replaceLocalServerCheck(ClassTransformationContext context, MethodNode methodNode, String owner, String name) { if (methodNode == null) { return false; } @@ -75,64 +87,11 @@ public final class RenderPatch extends PatchSupport { } MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!remappedOwner.equals(methodInsnNode.owner) || !remappedName.equals(methodInsnNode.name) || !"()Z".equals(methodInsnNode.desc)) { - continue; + if (remappedOwner.equals(methodInsnNode.owner) && remappedName.equals(methodInsnNode.name) && "()Z".equals(methodInsnNode.desc)) { + this.replaceInstructionSafely(context, methodNode, instruction, new MethodInsnNode(INVOKESTATIC, OBJECTS, "nonNull", "(" + objectDesc(OBJECT) + ")Z")); + modified = true; } - - InsnList replacement = new InsnList(); - replacement.add(new InsnNode(POP)); - replacement.add(new InsnNode(ICONST_1)); - methodNode.instructions.insertBefore(instruction, replacement); - methodNode.instructions.remove(instruction); - modified = true; } - - return modified; - } - - - private boolean patchCapeLayer(ClassTransformationContext context) { - boolean modified = false; - // 19w39a ~ 19w44a - modified |= this.applyIfMatches("[556,560]", "cape-layer.render.v1", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + "FFFFFFF)V"), - RENDER_TYPE - ), false); - // 19w45a ~ 1.21.1 (1.15 ~ 1.21.1) - modified |= this.applyIfMatches("[561,767],[801,803],[0x40000001,0x400000CC]", "cape-layer.render.v2", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + "FFFFFF)V"), - RENDER_TYPE - ), false); - // 24w33a ~ 1.21.8 (1.21.2 ~ 1.21.8) - modified |= this.applyIfMatches("[768,772],[0x400000CD,0x40000103]", "cape-layer.render.v3", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(CAPE_LAYER, "render", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(PLAYER_RENDER_STATE) + "FF)V"), - RENDER_TYPE - ), false); - // 25w31a ~ 25w42a (1.21.9 ~ 1.21.10) - modified |= this.applyIfMatches("773,[0x40000104,0x40000112]", "cape-layer.submit.v1", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(CAPE_LAYER, "submit", "(" + objectDesc(POSE_STACK) + objectDesc(SUBMIT_NODE_COLLECTOR) + "I" + objectDesc(AVATAR_RENDER_STATE) + "FF)V"), - RENDER_TYPE - ), false); - // 25w43a+ (1.21.11+) - modified |= this.applyIfMatches("[774,800],[804,0x40000000],[0x40000113,]", "cape-layer.submit.v2", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(CAPE_LAYER, "submit", "(" + objectDesc(POSE_STACK) + objectDesc(SUBMIT_NODE_COLLECTOR) + "I" + objectDesc(AVATAR_RENDER_STATE) + "FF)V"), - RENDER_TYPES - ), false); - return modified; - } - - private boolean patchPlayerRenderer(ClassTransformationContext context) { - boolean modified = false; - // 19w39a ~ 19w44a - modified |= this.applyIfMatches("[556,560]", "player-renderer.render-hand.v1", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(PLAYER_RENDERER, "renderHand", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + objectDesc(ABSTRACT_CLIENT_PLAYER) + objectDesc(MODEL_PART) + objectDesc(MODEL_PART) + ")V"), - RENDER_TYPE - ), false); - // 19w45a ~ 1.21.1 (1.15 ~ 1.21.1) - modified |= this.applyIfMatches("[561,767],[801,803],[0x40000001,0x400000CC]", "player-renderer.render-hand.v2", () -> replaceEntitySolidWithTranslucent( - context, context.findMethod(PLAYER_RENDERER, "renderHand", "(" + objectDesc(POSE_STACK) + objectDesc(MULTI_BUFFER_SOURCE) + "I" + objectDesc(ABSTRACT_CLIENT_PLAYER) + objectDesc(MODEL_PART) + objectDesc(MODEL_PART) + ")V"), - RENDER_TYPE - ), false); return modified; } @@ -153,16 +112,11 @@ public final class RenderPatch extends PatchSupport { } MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!remappedOwner.equals(methodInsnNode.owner) || !originalName.equals(methodInsnNode.name) || !remappedDesc.equals(methodInsnNode.desc)) { - continue; + if (remappedOwner.equals(methodInsnNode.owner) && originalName.equals(methodInsnNode.name) && remappedDesc.equals(methodInsnNode.desc)) { + this.replaceInstructionSafely(context, methodNode, instruction, new MethodInsnNode(INVOKESTATIC, remappedOwner, replacementName, remappedDesc, false)); + modified = true; } - - methodNode.instructions.insertBefore(instruction, new InsnNode(DUP)); - methodNode.instructions.insert(instruction, new MethodInsnNode(INVOKESTATIC, remappedOwner, replacementName, remappedDesc, false)); - methodNode.instructions.insert(instruction, new InsnNode(POP)); - modified = true; } - return modified; } } diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinManagerPatch.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinManagerPatch.java index 1ad10b6..8f7942a 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinManagerPatch.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinManagerPatch.java @@ -7,6 +7,7 @@ import org.objectweb.asm.Handle; import org.objectweb.asm.Type; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.FieldInsnNode; +import org.objectweb.asm.tree.FrameNode; import org.objectweb.asm.tree.InsnList; import org.objectweb.asm.tree.InsnNode; import org.objectweb.asm.tree.InvokeDynamicInsnNode; @@ -17,83 +18,182 @@ import org.objectweb.asm.tree.VarInsnNode; public final class SkinManagerPatch extends PatchSupport { public SkinManagerPatch() { - super( - "customskinloader:skin-manager-patch", 1000, - targets( - SKIN_MANAGER, "", - SKIN_MANAGER_1, "[764,800],[804,0x40000000],[0x40000090,]", // 23w31a+ (1.20.2+) - SKIN_MANAGER_3, "[,340]", // 1.12.2- - SKIN_MANAGER_CACHE_KEY, "[764,800],[804,0x40000000],[0x40000090,]", // 23w31a+ (1.20.2+) - SKIN_MANAGER_TEXTURE_CACHE, "[764,800],[804,0x40000000],[0x40000090,]" // 23w31a+ (1.20.2+) - ) - ); - } + super("customskinloader:skin-manager-patch", 1000); - @Override - public boolean transform(ClassTransformationContext context) { - boolean modified = false; + // 23w31a+ (1.20.2+) + this.rule("skin-manager.cache-key-inner-class", SKIN_MANAGER, "[764,800],[804,0x40000000],[0x40000090,]", context -> + this.makeInnerClassPublicNonFinal(context.getCurrentClassNode(), context.remapClassName(SKIN_MANAGER_CACHE_KEY))); - if (context.isTarget(SKIN_MANAGER)) { - // 23w31a+ (1.20.2+) - modified |= this.applyIfMatches("[764,800],[804,0x40000000],[0x40000090,]", "skin-manager.cache-key-inner-class", () -> makeInnerClassPublicNonFinal(context.getCurrentClassNode(), context.remapClassName(SKIN_MANAGER_CACHE_KEY))); - modified |= this.requireModified("skin-manager", this.patchSkinManager(context)); - } - if (context.isTarget(SKIN_MANAGER_1)) { - modified |= this.requireModified("skin-manager-1", this.patchSkinManagerLoader(context)); - } - if (context.isTarget(SKIN_MANAGER_3)) { - MethodNode getUserProfile = context.findMethod(SKIN_MANAGER_3, "run", "()V"); - modified |= this.requireModified("skin-manager-3", getUserProfile != null && this.replaceGetTexturesWithFakeUserProfile(getUserProfile)); - } - if (context.isTarget(SKIN_MANAGER_CACHE_KEY)) { - modified |= this.requireModified("skin-manager-cache-key", this.patchSkinManagerCacheKeyClass(context)); - } - if (context.isTarget(SKIN_MANAGER_TEXTURE_CACHE)) { - modified |= this.requireModified("skin-manager-texture-cache", this.patchSkinManagerTextureCache(context)); - } - - return modified; - } - - private boolean patchSkinManager(ClassTransformationContext context) { - boolean modified = false; - modified |= this.injectSkinManagerConstructors(context); // 1.20.1- - modified |= this.applyIfMatches("[,763],[801,803],[0x40000001,0x4000008E]", "skin-manager.v1", () -> patchLegacySkinManager(context)); - // 23w42a+ (1.20.3+) - modified |= this.applyIfMatches("[765,800],[804,0x40000000],[0x4000009D,]", "skin-manager.v2", () -> patchSkinManagerCacheKey(context)); - return modified; - } - - private boolean patchSkinManagerCacheKeyClass(ClassTransformationContext context) { - boolean modified = this.makeClassPublicNonFinal(context.getCurrentClassNode()); - modified |= this.makeMethodPublicNonFinal(context.findMethod(SKIN_MANAGER_CACHE_KEY, "", "(" + objectDesc(UUID) + objectDesc(PROPERTY) + ")V")); - return modified; - } - - private boolean injectSkinManagerConstructors(ClassTransformationContext context) { - boolean modified = false; - // 1.20.1- - modified |= this.applyIfMatches("[,763],[801,803],[0x40000001,0x4000008E]", "skin-manager..v1", () -> injectSetSkinCacheDir( - context, "(" + objectDesc(TEXTURE_MANAGER) + objectDesc(FILE) + objectDesc(MINECRAFT_SESSION_SERVICE) + ")V", 2, objectDesc(FILE) - )); + this.rule("skin-manager.constructor.v1", SKIN_MANAGER, "[,763],[801,803],[0x40000001,0x4000008E]", context -> + this.injectSetSkinCacheDir(context, "(" + objectDesc(TEXTURE_MANAGER) + objectDesc(FILE) + objectDesc(MINECRAFT_SESSION_SERVICE) + ")V", 2, objectDesc(FILE))); // 23w31a ~ 24w45a (1.20.2 ~ 1.21.3) - modified |= this.applyIfMatches("[764,768],[0x40000090,0x400000DD]", "skin-manager..v2", () -> injectSetSkinCacheDir( - context, "(" + objectDesc(TEXTURE_MANAGER) + objectDesc(PATH) + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(EXECUTOR) + ")V", 2, objectDesc(PATH) - )); + this.rule("skin-manager.constructor.v2", SKIN_MANAGER, "[764,768],[0x40000090,0x400000DD]", context -> + this.injectSetSkinCacheDir(context, "(" + objectDesc(TEXTURE_MANAGER) + objectDesc(PATH) + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(EXECUTOR) + ")V", 2, objectDesc(PATH))); // 24w46a ~ 25w33a (1.21.4 ~ 1.21.8) - modified |= this.applyIfMatches("[769,772],[0x400000DE,0x40000106]", "skin-manager..v3", () -> injectSetSkinCacheDir( - context, "(" + objectDesc(PATH) + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH) - )); + this.rule("skin-manager.constructor.v3", SKIN_MANAGER, "[769,772],[0x400000DE,0x40000106]", context -> + this.injectSetSkinCacheDir(context, "(" + objectDesc(PATH) + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH))); // 25w34a ~ 25w34b - modified |= this.applyIfMatches("[0x40000107,0x40000108]", "skin-manager..v4", () -> injectSetSkinCacheDir( - context, "(" + objectDesc(PATH) + objectDesc(SERVICES) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH) - )); + this.rule("skin-manager.constructor.v4", SKIN_MANAGER, "[0x40000107,0x40000108]", context -> + this.injectSetSkinCacheDir(context, "(" + objectDesc(PATH) + objectDesc(SERVICES) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH))); // 25w35a+ (1.21.9+) - modified |= this.applyIfMatches("[773,800],[804,0x40000000],[0x40000109,]", "skin-manager..v5", () -> injectSetSkinCacheDir( - context, "(" + objectDesc(PATH) + objectDesc(SERVICES) + objectDesc(SKIN_TEXTURE_DOWNLOADER) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH) - )); - return modified; + this.rule("skin-manager.constructor.v5", SKIN_MANAGER, "[773,800],[804,0x40000000],[0x40000109,]", context -> + this.injectSetSkinCacheDir(context, "(" + objectDesc(PATH) + objectDesc(SERVICES) + objectDesc(SKIN_TEXTURE_DOWNLOADER) + objectDesc(EXECUTOR) + ")V", 1, objectDesc(PATH))); + + // 19w37a- (1.14.4-) + this.rule("skin-manager.register-texture.v1", SKIN_MANAGER, "[,553]", context -> { + InsnList loadTextureType = new InsnList(); + loadTextureType.add(new VarInsnNode(ALOAD, 2)); + return this.redirectHttpTextureConstructorToFake( + context, + context.findMethod(SKIN_MANAGER, "registerTexture", "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + ")" + objectDesc(IDENTIFIER)), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + objectDesc(HTTP_TEXTURE_PROCESSOR) + ")V"), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + objectDesc(HTTP_TEXTURE_PROCESSOR) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), + loadTextureType + ); + }); + // 19w38a ~ 1.20.1 (1.15 ~ 1.20.1) + this.rule("skin-manager.register-texture.v2", SKIN_MANAGER, "[554,763],[801,803],[0x40000001,0x4000008E]", context -> { + InsnList loadTextureType = new InsnList(); + loadTextureType.add(new VarInsnNode(ALOAD, 2)); + return this.redirectHttpTextureConstructorToFake( + context, + context.findMethod(SKIN_MANAGER, "registerTexture", "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + ")" + objectDesc(IDENTIFIER)), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + ")V"), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), + loadTextureType + ); + }); + + // 19w37a- (1.14.4-) + this.rule("skin-manager.register-skins.v1", SKIN_MANAGER, "[,553]", context -> + this.replaceExecutorProfileLoadAtInvocation( + context, context.findMethod(SKIN_MANAGER, "registerSkins", "(" + objectDesc(GAME_PROFILE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + "Z)V"), + EXECUTOR_SERVICE, "submit", "(" + objectDesc(RUNNABLE) + ")" + objectDesc(FUTURE))); + // 19w38a ~ 1.18-exp7 (1.15 ~ 1.17.1) + this.rule("skin-manager.register-skins.v2", SKIN_MANAGER, "[554,756],[801,803],[0x40000001,0x4000002F]+[2205,2831]", context -> + this.replaceExecutorProfileLoadAtInvocation( + context, context.findMethod(SKIN_MANAGER, "registerSkins", "(" + objectDesc(GAME_PROFILE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + "Z)V"), + EXECUTOR, "execute", "(" + objectDesc(RUNNABLE) + ")V")); + // 21w37a ~ 1.20.1 (1.18 ~ 1.20.1) + this.rule("skin-manager.register-skins.v3", SKIN_MANAGER, "[757,763],[0x40000029,0x4000008E]+[2834,3465]", context -> + this.replaceExecutorProfileLoadAtInvocation( + context, context.findMethod(SKIN_MANAGER, "registerSkins", "(" + objectDesc(GAME_PROFILE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + "Z)V"), + EXECUTOR_SERVICE, "execute", "(" + objectDesc(RUNNABLE) + ")V")); + + this.rule("skin-manager.get-insecure-skin-information", SKIN_MANAGER, "[,763],[801,803],[0x40000001,0x4000008E]", context -> { + MethodNode methodNode = context.findMethod(SKIN_MANAGER, "getInsecureSkinInformation", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(MAP)); + if (methodNode == null) { + return false; + } + InsnList injection = new InsnList(); + injection.add(new VarInsnNode(ALOAD, 1)); + injection.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(MAP), false)); + injection.add(new InsnNode(ARETURN)); + injection.add(new FrameNode(F_SAME, 0, null, 0, null)); + methodNode.instructions.insert(injection); + return true; + }); + + // 1.13.2 ~ 1.20.1 + this.rule("skin-manager.lambda-register-skins-4", SKIN_MANAGER, "[404,763],[801,803],[0x40000001,0x4000008E]", context -> + this.replaceGetTexturesWithFakeUserProfile(context, context.findMethod(SKIN_MANAGER, "lambda$registerSkins$4", + "(" + objectDesc(GAME_PROFILE) + "Z" + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + ")V"))); + + // 23w42a ~ 25w33a (1.20.3 ~ 1.21.8) + this.rule("skin-manager.cache-key.v1", SKIN_MANAGER, "[765,772],[0x4000009D,0x40000106]", context -> + this.redirectCacheKeyConstruction(context, context.findMethod(SKIN_MANAGER, "getOrLoad", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(COMPLETABLE_FUTURE)))); + // 25w34a+ (1.21.9+) + this.rule("skin-manager.cache-key.v2", SKIN_MANAGER, "[773,800],[804,0x40000000],[0x40000107,]", context -> + this.redirectCacheKeyConstruction(context, context.findMethod(SKIN_MANAGER, "get", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(COMPLETABLE_FUTURE)))); + + // 23w31a+ (1.20.2+) + this.rule("skin-manager-1.executor", SKIN_MANAGER_1, "[764,800],[804,0x40000000],[0x40000090,]", context -> { + MethodNode methodNode = context.findMethod(SKIN_MANAGER_1, "load", "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + ")" + objectDesc(COMPLETABLE_FUTURE)); + if (methodNode == null) { + return false; + } + boolean modified = false; + for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { + if (!(instruction instanceof MethodInsnNode)) { + continue; + } + MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; + if (COMPLETABLE_FUTURE.equals(methodInsnNode.owner) + && (("supplyAsync".equals(methodInsnNode.name) && ("(" + objectDesc(SUPPLIER) + objectDesc(EXECUTOR) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc)) + || ("thenComposeAsync".equals(methodInsnNode.name) && ("(" + objectDesc(FUNCTION) + objectDesc(EXECUTOR) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc)))) { + methodNode.instructions.insertBefore(instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadProfileTextures", "(" + objectDesc(EXECUTOR) + ")" + objectDesc(EXECUTOR), false)); + modified = true; + } + } + return modified; + }); + + // 23w31a ~ 23w41a (1.20.2) + this.rule("skin-manager-1.lambda-load-0.v1", SKIN_MANAGER_1, "764,[0x40000090,0x4000009C]", context -> { + MethodNode methodNode = context.findMethod(SKIN_MANAGER_1, "lambda$load$0", "(" + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(GAME_PROFILE) + ")" + objectDesc(SKIN_MANAGER_TEXTURE_INFO)); + if (methodNode == null) { + return false; + } + boolean modified = false; + for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { + if (!(instruction instanceof MethodInsnNode)) { + continue; + } + MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; + if (MINECRAFT_SESSION_SERVICE.equals(methodInsnNode.owner) && "getTextures".equals(methodInsnNode.name) + && ("(" + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP)).equals(methodInsnNode.desc)) { + this.replaceInstructionSafely(context, methodNode, instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", "(" + objectDesc(OBJECT) + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP), false)); + modified = true; + } + } + return modified; + }); + // 23w42a ~ 25w33a (1.20.3 ~ 1.21.8) + this.rule("skin-manager-1.lambda-load-0.v2", SKIN_MANAGER_1, "[765,772],[0x4000009D,0x40000106]", context -> + this.replaceUnpackTexturesWithFakeSkinCache(context, context.findMethod(SKIN_MANAGER_1, "lambda$load$0", + "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + objectDesc(MINECRAFT_SESSION_SERVICE) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)), MINECRAFT_SESSION_SERVICE)); + // 25w34a ~ 26.3-snapshot-1 (1.21.9 ~ 26.2) + this.rule("skin-manager-1.lambda-load-0.v3", SKIN_MANAGER_1, "[773,776],[0x40000107,0x40000143]", context -> + this.replaceUnpackTexturesWithFakeSkinCache(context, context.findMethod(SKIN_MANAGER_1, "lambda$load$0", + "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + objectDesc(SERVICES) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)), MINECRAFT_SESSION_SERVICE)); + // 26.3-snapshot-2+ (26.3+) + this.rule("skin-manager-1.lambda-load-0.v4", SKIN_MANAGER_1, "[777,800],[804,0x40000000],[0x40000144,]", context -> + this.replaceUnpackTexturesWithFakeSkinCache(context, context.findMethod(SKIN_MANAGER_1, "lambda$load$0", + "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + objectDesc(SERVICES) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)), SESSION_SERVICE)); + + // 1.12.2- + this.rule("skin-manager-3.get-user-profile", SKIN_MANAGER_3, "[,340]", context -> + this.replaceGetTexturesWithFakeUserProfile(context, context.findMethod(SKIN_MANAGER_3, "run", "()V"))); + + // 23w31a+ (1.20.2+) + this.rule("skin-manager-cache-key.access", SKIN_MANAGER_CACHE_KEY, "[764,800],[804,0x40000000],[0x40000090,]", context -> { + boolean modified = this.makeClassPublicNonFinal(context.getCurrentClassNode()); + modified |= this.makeMethodPublicNonFinal(context.findMethod(SKIN_MANAGER_CACHE_KEY, "", "(" + objectDesc(UUID) + objectDesc(PROPERTY) + ")V")); + return modified; + }); + + // 23w31a ~ 24w45a (1.20.2 ~ 1.21.3) + this.rule("skin-manager-texture-cache.http-texture", SKIN_MANAGER_TEXTURE_CACHE, "[764,768],[0x40000090,0x400000DD]", context -> { + InsnList loadType = new InsnList(); + loadType.add(new VarInsnNode(ALOAD, 0)); + loadType.add(new FieldInsnNode(GETFIELD, context.remapClassName(SKIN_MANAGER_TEXTURE_CACHE), context.remapFieldName(SKIN_MANAGER_TEXTURE_CACHE, "type"), objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE))); + return this.redirectHttpTextureConstructorToFake( + context, + context.findMethod(SKIN_MANAGER_TEXTURE_CACHE, "registerTexture", "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + ")" + objectDesc(COMPLETABLE_FUTURE)), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + ")V"), + context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), + loadType + ); + }); + // 24w46a ~ 25w34b (1.21.4 ~ 1.21.8) + this.rule("skin-manager-texture-cache.skin-texture-downloader.v1", SKIN_MANAGER_TEXTURE_CACHE, "[769,772],[0x400000DE,0x40000108]", context -> + this.redirectSkinTextureDownloaderToFake(context, context.findMethod(SKIN_MANAGER_TEXTURE_CACHE, "registerTexture", + "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + ")" + objectDesc(COMPLETABLE_FUTURE)), INVOKESTATIC)); + // 25w35a+ (1.21.9+) + this.rule("skin-manager-texture-cache.skin-texture-downloader.v2", SKIN_MANAGER_TEXTURE_CACHE, "[773,800],[804,0x40000000],[0x40000109,]", context -> + this.redirectSkinTextureDownloaderToFake(context, context.findMethod(SKIN_MANAGER_TEXTURE_CACHE, "registerTexture", + "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + ")" + objectDesc(COMPLETABLE_FUTURE)), INVOKEVIRTUAL)); } private boolean injectSetSkinCacheDir(ClassTransformationContext context, String constructorDesc, int localIndex, String argumentDesc) { @@ -118,153 +218,6 @@ public final class SkinManagerPatch extends PatchSupport { return modified; } - private boolean patchLegacySkinManager(ClassTransformationContext context) { - boolean modified = false; - modified |= this.requireModified("skin-manager.v1.register-texture", this.patchLegacySkinManagerRegisterTexture(context)); - modified |= this.requireModified("skin-manager.v1.register-skins", this.patchLegacySkinManagerRegisterSkins(context)); - modified |= this.requireModified("skin-manager.v1.get-insecure-skin-information", this.patchLegacySkinManagerGetInsecureSkinInformation(context)); - // 1.13.2 ~ 1.20.1 - modified |= this.applyIfMatches("[404,763],[801,803],[0x40000001,0x4000008E]", "skin-manager.v1.lambda-register-skins-4", () -> patchLegacySkinManagerGetUserProfile(context)); - return modified; - } - - private boolean patchLegacySkinManagerRegisterTexture(ClassTransformationContext context) { - MethodNode registerTexture = context.findMethod(SKIN_MANAGER, "registerTexture", "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + ")" + objectDesc(IDENTIFIER)); - if (registerTexture == null) { - return false; - } - - InsnList insnList = new InsnList(); - insnList.add(new VarInsnNode(ALOAD, 2)); - return this.patchCreateThreadDownloadImageData(context, registerTexture, insnList); - } - - private boolean patchLegacySkinManagerRegisterSkins(ClassTransformationContext context) { - MethodNode registerSkins = context.findMethod(SKIN_MANAGER, "registerSkins", "(" + objectDesc(GAME_PROFILE) + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + "Z)V"); - if (registerSkins == null) { - return false; - } - - boolean modified = false; - // 19w37a- (1.14.4-) - modified |= this.applyIfMatches("[,553]", "skin-manager.register-skins.v1", () -> replaceExecutorProfileLoadAtInvocation(registerSkins, EXECUTOR_SERVICE, "submit", "(" + objectDesc(RUNNABLE) + ")" + objectDesc(FUTURE), true)); - // 19w38a ~ 1.18-exp7 (1.15 ~ 1.17.1) - modified |= this.applyIfMatches("[554,756],[801,803],[0x40000001,0x4000002F]+[2205,2831]", "skin-manager.register-skins.v2", () -> replaceExecutorProfileLoadAtInvocation(registerSkins, EXECUTOR, "execute", "(" + objectDesc(RUNNABLE) + ")V", false)); - // 21w37a ~ 1.20.1 (1.18 ~ 1.20.1) - modified |= this.applyIfMatches("[757,763],[0x40000029,0x4000008E]+[2834,3465]", "skin-manager.register-skins.v3", () -> replaceExecutorProfileLoadAtInvocation(registerSkins, EXECUTOR_SERVICE, "execute", "(" + objectDesc(RUNNABLE) + ")V", false)); - return modified; - } - - private boolean patchLegacySkinManagerGetInsecureSkinInformation(ClassTransformationContext context) { - MethodNode loadSkinFromCache = context.findMethod(SKIN_MANAGER, "getInsecureSkinInformation", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(MAP)); - if (loadSkinFromCache == null) { - return false; - } - - return this.replaceLoadSkinFromCacheMethod(loadSkinFromCache); - } - - private boolean patchLegacySkinManagerGetUserProfile(ClassTransformationContext context) { - MethodNode getUserProfile = context.findMethod(SKIN_MANAGER, "lambda$registerSkins$4", "(" + objectDesc(GAME_PROFILE) + "Z" + objectDesc(SKIN_MANAGER_SKIN_TEXTURE_CALLBACK) + ")V"); - if (getUserProfile == null) { - return false; - } - - return this.replaceGetTexturesWithFakeUserProfile(getUserProfile); - } - - private boolean patchSkinManagerCacheKey(ClassTransformationContext context) { - boolean modified = false; - // 23w42a ~ 25w33a (1.20.3 ~ 1.21.8) - modified |= this.applyIfMatches("[765,772],[0x4000009D,0x40000106]", "skin-manager.cache-key.v1", () -> { - MethodNode getOrLoad = context.findMethod(SKIN_MANAGER, "getOrLoad", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(COMPLETABLE_FUTURE)); - return getOrLoad != null && redirectCacheKeyConstruction(context, getOrLoad); - }); - // 25w34a+ (1.21.9+) - modified |= this.applyIfMatches("[773,800],[804,0x40000000],[0x40000107,]", "skin-manager.cache-key.v2", () -> { - MethodNode get = context.findMethod(SKIN_MANAGER, "get", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(COMPLETABLE_FUTURE)); - return get != null && redirectCacheKeyConstruction(context, get); - }); - return modified; - } - - private boolean patchSkinManagerLoader(ClassTransformationContext context) { - boolean modified = false; - MethodNode load = context.findMethod(SKIN_MANAGER_1, "load", "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + ")" + objectDesc(COMPLETABLE_FUTURE)); - modified |= this.requireModified("skin-manager-1.executor", load != null && this.replaceCompletableFutureExecutor(load)); - - modified |= this.patchSkinManagerLoaderLambda(context); - - return modified; - } - - private boolean patchSkinManagerLoaderLambda(ClassTransformationContext context) { - boolean modified = false; - // 23w31a ~ 23w41a (1.20.2) - modified |= this.applyIfMatches("764,[0x40000090,0x4000009C]", "skin-manager-1.lambda-load-0.v1", () -> { - MethodNode oldLambda = context.findMethod(SKIN_MANAGER_1, "lambda$load$0", "(" + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(GAME_PROFILE) + ")" + objectDesc(SKIN_MANAGER_TEXTURE_INFO)); - return oldLambda != null && replaceGetTexturesWithFakeSkinCache(oldLambda); - }); - // 23w42a ~ 25w33a (1.20.3 ~ 1.21.8) - modified |= this.applyIfMatches("[765,772],[0x4000009D,0x40000106]", "skin-manager-1.lambda-load-0.v2", () -> { - MethodNode lambdaWithSession = context.findMethod(SKIN_MANAGER_1, "lambda$load$0", "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + objectDesc(MINECRAFT_SESSION_SERVICE) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)); - return lambdaWithSession != null && replaceUnpackTexturesWithFakeSkinCache(context, lambdaWithSession); - }); - // 25w34a+ (1.21.9+) - modified |= this.applyIfMatches("[773,800],[804,0x40000000],[0x40000107,]", "skin-manager-1.lambda-load-0.v3", () -> { - MethodNode lambdaWithServices = context.findMethod(SKIN_MANAGER_1, "lambda$load$0", "(" + objectDesc(SKIN_MANAGER_CACHE_KEY) + objectDesc(SERVICES) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)); - return lambdaWithServices != null && replaceUnpackTexturesWithFakeSkinCache(context, lambdaWithServices); - }); - return modified; - } - - private boolean patchSkinManagerTextureCache(ClassTransformationContext context) { - MethodNode registerTexture = context.findMethod(SKIN_MANAGER_TEXTURE_CACHE, "registerTexture", "(" + objectDesc(MINECRAFT_PROFILE_TEXTURE) + ")" + objectDesc(COMPLETABLE_FUTURE)); - if (registerTexture == null) { - return false; - } - - String fieldName = context.remapFieldName(SKIN_MANAGER_TEXTURE_CACHE, "type"); - InsnList loadType = new InsnList(); - loadType.add(new VarInsnNode(ALOAD, 0)); - loadType.add(new FieldInsnNode(GETFIELD, context.remapClassName(SKIN_MANAGER_TEXTURE_CACHE), fieldName, objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE))); - - boolean modified = false; - // 23w31a ~ 24w45a (1.20.2 ~ 1.21.3) - modified |= this.applyIfMatches("[764,768],[0x40000090,0x400000DD]", "skin-manager-texture-cache.http-texture", () -> redirectHttpTextureConstructorToFake( - context, registerTexture, context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + ")V"), - context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), - loadType - )); - // 24w46a ~ 25w34b (1.21.4 ~ 1.21.8) - modified |= this.applyIfMatches("[769,772],[0x400000DE,0x40000108]", "skin-manager-texture-cache.skin-texture-downloader.v1", () -> redirectSkinTextureDownloaderToFake( - context, registerTexture, INVOKESTATIC - )); - // 25w35a+ (1.21.9+) - modified |= this.applyIfMatches("[773,800],[804,0x40000000],[0x40000109,]", "skin-manager-texture-cache.skin-texture-downloader.v2", () -> redirectSkinTextureDownloaderToFake( - context, registerTexture, INVOKEVIRTUAL - )); - return modified; - } - - - private boolean patchCreateThreadDownloadImageData(ClassTransformationContext context, MethodNode methodNode, InsnList loadTextureType) { - boolean modified = false; - // 19w37a- (1.14.4-) - modified |= this.applyIfMatches("[,553]", "skin-manager.http-texture.v1", () -> redirectHttpTextureConstructorToFake( - context, methodNode, context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + objectDesc(HTTP_TEXTURE_PROCESSOR) + ")V"), - context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + objectDesc(HTTP_TEXTURE_PROCESSOR) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), - loadTextureType - )); - // 19w38a ~ 1.20.1 (1.15 ~ 1.20.1) - modified |= this.applyIfMatches("[554,763],[801,803],[0x40000001,0x4000008E]", "skin-manager.http-texture.v2", () -> redirectHttpTextureConstructorToFake( - context, methodNode, context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + ")V"), - context.remapMethodDescriptor("(" + objectDesc(FILE) + objectDesc(STRING) + objectDesc(IDENTIFIER) + "Z" + objectDesc(RUNNABLE) + objectDesc(MINECRAFT_PROFILE_TEXTURE) + objectDesc(MINECRAFT_PROFILE_TEXTURE_TYPE) + ")V"), - loadTextureType - )); - return modified; - } - private boolean redirectHttpTextureConstructorToFake(ClassTransformationContext context, MethodNode methodNode, String originalDesc, String replacementDesc, InsnList loadTextureType) { if (methodNode == null) { return false; @@ -341,7 +294,7 @@ public final class SkinManagerPatch extends PatchSupport { } injection.add(new VarInsnNode(ALOAD, 1)); methodNode.instructions.insertBefore(methodInsnNode, injection); - methodNodeSet(methodNode, methodInsnNode, new MethodInsnNode(INVOKESTATIC, FAKE_HTTP_TEXTURE_V2, "downloadAndRegisterSkin", replacementDesc, false)); + methodNode.instructions.set(methodInsnNode, new MethodInsnNode(INVOKESTATIC, FAKE_HTTP_TEXTURE_V2, "downloadAndRegisterSkin", replacementDesc, false)); modified = true; } return modified; @@ -365,7 +318,11 @@ public final class SkinManagerPatch extends PatchSupport { return false; } - private boolean replaceExecutorProfileLoadAtInvocation(MethodNode methodNode, String owner, String name, String desc, boolean pushNullReturn) { + private boolean replaceExecutorProfileLoadAtInvocation(ClassTransformationContext context, MethodNode methodNode, String owner, String name, String desc) { + if (methodNode == null) { + return false; + } + boolean modified = false; for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { if (!(instruction instanceof MethodInsnNode)) { @@ -377,31 +334,21 @@ public final class SkinManagerPatch extends PatchSupport { continue; } - InsnList replacement = new InsnList(); - replacement.add(new InsnNode(SWAP)); - replacement.add(new InsnNode(POP)); - replacement.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadProfileTextures", "(" + objectDesc(RUNNABLE) + ")V", false)); - if (pushNullReturn) { - replacement.add(new InsnNode(ACONST_NULL)); + this.replaceInstructionSafely(context, methodNode, instruction, methodInsnNode = new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadProfileTextures", "(" + objectDesc(OBJECT) + objectDesc(RUNNABLE) + ")V", false)); + if (!desc.endsWith("V")) { + methodNode.instructions.insert(methodInsnNode, new InsnNode(ACONST_NULL)); } - methodNode.instructions.insertBefore(instruction, replacement); - methodNode.instructions.remove(instruction); modified = true; + break; } return modified; } - private boolean replaceLoadSkinFromCacheMethod(MethodNode methodNode) { - methodNode.instructions.clear(); - methodNode.tryCatchBlocks.clear(); - methodNode.instructions.add(new VarInsnNode(ALOAD, 1)); - methodNode.instructions.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", "(" + objectDesc(GAME_PROFILE) + ")" + objectDesc(MAP), false)); - methodNode.instructions.add(new InsnNode(ARETURN)); - methodNode.maxLocals = Math.max(methodNode.maxLocals, 2); - return true; - } + private boolean replaceGetTexturesWithFakeUserProfile(ClassTransformationContext context, MethodNode methodNode) { + if (methodNode == null) { + return false; + } - private boolean replaceGetTexturesWithFakeUserProfile(MethodNode methodNode) { boolean modified = false; for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { if (!(instruction instanceof MethodInsnNode)) { @@ -413,13 +360,17 @@ public final class SkinManagerPatch extends PatchSupport { continue; } - methodNode.instructions.set(instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "getUserProfile", "(" + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP), false)); + this.replaceInstructionSafely(context, methodNode, instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "getUserProfile", "(" + objectDesc(OBJECT) + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP), false)); modified = true; } return modified; } private boolean redirectCacheKeyConstruction(ClassTransformationContext context, MethodNode methodNode) { + if (methodNode == null) { + return false; + } + boolean modified = false; String owner = context.remapClassName(SKIN_MANAGER_CACHE_KEY); String desc = context.remapMethodDescriptor("(" + objectDesc(UUID) + objectDesc(PROPERTY) + ")V"); @@ -455,49 +406,13 @@ public final class SkinManagerPatch extends PatchSupport { return modified; } - private boolean replaceCompletableFutureExecutor(MethodNode methodNode) { - boolean modified = false; - for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { - if (!(instruction instanceof MethodInsnNode)) { - continue; - } - - MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!COMPLETABLE_FUTURE.equals(methodInsnNode.owner)) { - continue; - } - if (("supplyAsync".equals(methodInsnNode.name) && ("(" + objectDesc(SUPPLIER) + objectDesc(EXECUTOR) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc)) - || ("thenComposeAsync".equals(methodInsnNode.name) && ("(" + objectDesc(FUNCTION) + objectDesc(EXECUTOR) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc))) { - InsnList replacement = new InsnList(); - replacement.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadProfileTextures", "(" + objectDesc(EXECUTOR) + ")" + objectDesc(EXECUTOR), false)); - methodNode.instructions.insertBefore(instruction, replacement); - modified = true; - } + private boolean replaceUnpackTexturesWithFakeSkinCache(ClassTransformationContext context, MethodNode methodNode, String owner) { + if (methodNode == null) { + return false; } - return modified; - } - private boolean replaceGetTexturesWithFakeSkinCache(MethodNode methodNode) { boolean modified = false; - for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { - if (!(instruction instanceof MethodInsnNode)) { - continue; - } - - MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!MINECRAFT_SESSION_SERVICE.equals(methodInsnNode.owner) || !"getTextures".equals(methodInsnNode.name) || !("(" + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP)).equals(methodInsnNode.desc)) { - continue; - } - - methodNode.instructions.set(instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", "(" + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(GAME_PROFILE) + "Z)" + objectDesc(MAP), false)); - modified = true; - } - return modified; - } - - private boolean replaceUnpackTexturesWithFakeSkinCache(ClassTransformationContext context, MethodNode methodNode) { - boolean modified = false; - String desc = context.remapMethodDescriptor("(" + objectDesc(MINECRAFT_SESSION_SERVICE) + objectDesc(PROPERTY) + objectDesc(SKIN_MANAGER_CACHE_KEY) + ")" + objectDesc(OBJECT)); + String desc = context.remapMethodDescriptor("(" + objectDesc(OBJECT) + objectDesc(SKIN_MANAGER_CACHE_KEY) + ")" + objectDesc(OBJECT)); String returnType = context.remapClassName(MINECRAFT_PROFILE_TEXTURES); for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { @@ -506,16 +421,15 @@ public final class SkinManagerPatch extends PatchSupport { } MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!MINECRAFT_SESSION_SERVICE.equals(methodInsnNode.owner) || !"unpackTextures".equals(methodInsnNode.name) || !("(" + objectDesc(PROPERTY) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)).equals(methodInsnNode.desc)) { + if (!owner.equals(methodInsnNode.owner) || !"unpackTextures".equals(methodInsnNode.name) || !("(" + objectDesc(PROPERTY) + ")" + objectDesc(MINECRAFT_PROFILE_TEXTURES)).equals(methodInsnNode.desc)) { continue; } - InsnList replacement = new InsnList(); - replacement.add(new VarInsnNode(ALOAD, 0)); - replacement.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", desc, false)); - replacement.add(new TypeInsnNode(CHECKCAST, returnType)); - methodNode.instructions.insertBefore(instruction, replacement); - methodNode.instructions.remove(instruction); + InsnList insnList = new InsnList(); + insnList.add(new VarInsnNode(ALOAD, 0)); + insnList.add(new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_MANAGER, "loadSkinFromCache", desc, false)); + insnList.add(new TypeInsnNode(CHECKCAST, returnType)); + methodNode.instructions.insert(instruction, insnList); modified = true; } return modified; diff --git a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinTexturePatch.java b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinTexturePatch.java index 37a4c21..1f9aa08 100644 --- a/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinTexturePatch.java +++ b/Bootstrap/Core/src/main/java/customskinloader/bootstrap/transformer/patch/SkinTexturePatch.java @@ -1,101 +1,107 @@ package customskinloader.bootstrap.transformer.patch; import customskinloader.bootstrap.transformer.ClassTransformationContext; -import org.objectweb.asm.Handle; -import org.objectweb.asm.Type; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.FieldInsnNode; import org.objectweb.asm.tree.InsnList; import org.objectweb.asm.tree.InsnNode; -import org.objectweb.asm.tree.InvokeDynamicInsnNode; import org.objectweb.asm.tree.MethodInsnNode; import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.VarInsnNode; public final class SkinTexturePatch extends PatchSupport { public SkinTexturePatch() { - super( - "customskinloader:skin-texture-patch", 1000, - targets( - HTTP_TEXTURE, "[,768],[801,803],[0x40000001,0x400000DD]", // 24w45a- (1.21.3-) - SKIN_TEXTURE_DOWNLOADER, "[769,800],[804,0x40000000],[0x400000DE,]" // 24w46a+ (1.21.4+) - ) - ); - } + super("customskinloader:skin-texture-patch", 1000); - @Override - public boolean transform(ClassTransformationContext context) { - boolean modified = false; + // 24w45a- (1.21.3-) + this.rule("http-texture.uploaded", HTTP_TEXTURE, "[,768],[801,803],[0x40000001,0x400000DD]", context -> + this.makeFieldPublicNonFinal(context.findField(HTTP_TEXTURE, "uploaded"))); - if (context.isTarget(HTTP_TEXTURE)) { - // 24w45a- (1.21.3-) - modified |= this.applyIfMatches("[,768],[801,803],[0x40000001,0x400000DD]", "http-texture.uploaded", () -> this.makeFieldPublicNonFinal(context.findField(HTTP_TEXTURE, "uploaded"))); - // 19w38a ~ 24w45a (1.15 ~ 1.21.3) - modified |= this.applyIfMatches("[554,768],[801,803],[0x40000001,0x400000DD]", "http-texture.patch", () -> this.patchHttpTexture(context)); - } - if (context.isTarget(SKIN_TEXTURE_DOWNLOADER)) { - modified |= this.requireModified("skin-texture-downloader.patch", this.patchSkinTextureDownloader(context)); - } + // 19w38a ~ 24w45a (1.15 ~ 1.21.3) + this.rule("http-texture.process-legacy-skin", HTTP_TEXTURE, "[554,768],[801,803],[0x40000001,0x400000DD]", context -> { + MethodNode load = context.findMethod(HTTP_TEXTURE, "load", "(" + objectDesc(INPUT_STREAM) + ")" + objectDesc(NATIVE_IMAGE)); + if (load == null) { + return false; + } - return modified; - } + boolean modified = false; + String owner = context.remapClassName(HTTP_TEXTURE); + String originalName = context.remapMethodName(HTTP_TEXTURE, "processLegacySkin", "(" + objectDesc(NATIVE_IMAGE) + ")" + objectDesc(NATIVE_IMAGE)); + String imageDesc = context.remapMethodDescriptor("(" + objectDesc(NATIVE_IMAGE) + ")" + objectDesc(NATIVE_IMAGE)); + String conditionDesc = context.remapMethodDescriptor("(" + objectDesc(RUNNABLE) + ")Z"); + String replacementDesc = context.remapMethodDescriptor("(" + objectDesc(NATIVE_IMAGE) + objectDesc(RUNNABLE) + ")" + objectDesc(NATIVE_IMAGE)); + String processTaskField = context.remapFieldName(HTTP_TEXTURE, "onDownloaded"); + for (AbstractInsnNode instruction : load.instructions.toArray()) { + if (!(instruction instanceof MethodInsnNode)) { + continue; + } - private boolean patchHttpTexture(ClassTransformationContext context) { - return this.replaceHttpTextureProcessLegacySkin( - context, context.findMethod(HTTP_TEXTURE, "load", "(" + objectDesc(INPUT_STREAM) + ")" + objectDesc(NATIVE_IMAGE)) - ); - } + MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; + if (!owner.equals(methodInsnNode.owner) || !originalName.equals(methodInsnNode.name) || !imageDesc.equals(methodInsnNode.desc)) { + continue; + } + + load.instructions.insertBefore(instruction, new VarInsnNode(ALOAD, 0)); + load.instructions.insertBefore(instruction, new FieldInsnNode(GETFIELD, owner, processTaskField, objectDesc(RUNNABLE))); + MethodInsnNode processLegacySkin = new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_BUFFER, "processLegacySkin", replacementDesc, false); + this.replaceInstructionSafely(context, load, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_BUFFER, "shouldProcessLegacySkin", conditionDesc, false), IFNE, instruction, processLegacySkin); + + InsnList injection = new InsnList(); + if (methodInsnNode.getOpcode() == INVOKESTATIC) { + injection.add(new VarInsnNode(ALOAD, 0)); + } else { + injection.add(new InsnNode(SWAP)); + } + injection.add(new FieldInsnNode(GETFIELD, owner, processTaskField, objectDesc(RUNNABLE))); + load.instructions.insertBefore(processLegacySkin, injection); + modified = true; + } + return modified; + }); - private boolean patchSkinTextureDownloader(ClassTransformationContext context) { - boolean modified = false; - modified |= this.requireModified("skin-texture-downloader.then-compose", this.replaceThenComposeTextureFunction( - context, context.findMethod(SKIN_TEXTURE_DOWNLOADER, "downloadAndRegisterSkin", "(" + objectDesc(IDENTIFIER) + objectDesc(PATH) + objectDesc(STRING) + "Z)" + objectDesc(COMPLETABLE_FUTURE)) - )); // 24w46a+ (1.21.4+) - modified |= this.applyIfMatches("[769,800],[804,0x40000000],[0x400000DE,]", "skin-texture-downloader.process-legacy-skin", () -> replaceSkinTextureDownloaderProcessLegacySkin(context)); - return modified; - } - - private boolean replaceThenComposeTextureFunction(ClassTransformationContext context, MethodNode methodNode) { - if (methodNode == null) { - return false; - } - - boolean modified = false; - int locationLocal = (methodNode.access & ACC_STATIC) == 0 ? 1 : 0; - int booleanLocal = locationLocal + 3; - String remappedHookDesc = context.remapMethodDescriptor("(" + objectDesc(FUNCTION) + objectDesc(IDENTIFIER) + "Z)" + objectDesc(FUNCTION)); - for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { - if (!(instruction instanceof MethodInsnNode)) { - continue; + this.rule("skin-texture-downloader.then-compose", SKIN_TEXTURE_DOWNLOADER, "[769,800],[804,0x40000000],[0x400000DE,]", context -> { + MethodNode methodNode = context.findMethod(SKIN_TEXTURE_DOWNLOADER, "downloadAndRegisterSkin", + "(" + objectDesc(IDENTIFIER) + objectDesc(PATH) + objectDesc(STRING) + "Z)" + objectDesc(COMPLETABLE_FUTURE)); + if (methodNode == null) { + return false; } - MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!COMPLETABLE_FUTURE.equals(methodInsnNode.owner) || !"thenCompose".equals(methodInsnNode.name) || !("(" + objectDesc(FUNCTION) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc)) { - continue; + boolean modified = false; + int locationLocal = (methodNode.access & ACC_STATIC) == 0 ? 1 : 0; + int booleanLocal = locationLocal + 3; + String remappedHookDesc = context.remapMethodDescriptor("(" + objectDesc(FUNCTION) + objectDesc(IDENTIFIER) + "Z)" + objectDesc(FUNCTION)); + for (AbstractInsnNode instruction : methodNode.instructions.toArray()) { + if (!(instruction instanceof MethodInsnNode)) { + continue; + } + + MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; + if (!COMPLETABLE_FUTURE.equals(methodInsnNode.owner) || !"thenCompose".equals(methodInsnNode.name) + || !("(" + objectDesc(FUNCTION) + ")" + objectDesc(COMPLETABLE_FUTURE)).equals(methodInsnNode.desc)) { + continue; + } + + InsnList injection = new InsnList(); + injection.add(new VarInsnNode(ALOAD, locationLocal)); + injection.add(new VarInsnNode(ILOAD, booleanLocal)); + injection.add(new MethodInsnNode(INVOKESTATIC, FAKE_HTTP_TEXTURE_V2, "createTexture", remappedHookDesc, false)); + methodNode.instructions.insertBefore(instruction, injection); + modified = true; } + return modified; + }); - InsnList injection = new InsnList(); - injection.add(new VarInsnNode(ALOAD, locationLocal)); - injection.add(new VarInsnNode(ILOAD, booleanLocal)); - injection.add(new MethodInsnNode(INVOKESTATIC, FAKE_HTTP_TEXTURE_V2, "createTexture", remappedHookDesc, false)); - methodNode.instructions.insertBefore(instruction, injection); - modified = true; - } - return modified; - } - - private boolean replaceSkinTextureDownloaderProcessLegacySkin(ClassTransformationContext context) { - boolean modified = false; // 24w46a ~ 25w37a (1.21.4 ~ 1.21.8) - modified |= this.applyIfMatches("[769,772],[0x400000DE,0x4000010C]", "skin-texture-downloader.process-legacy-skin.v1", () -> replaceSkinTextureDownloaderProcessLegacySkin( - context, context.findMethod(SKIN_TEXTURE_DOWNLOADER, "lambda$downloadAndRegisterSkin$0", "(" + objectDesc(PATH) + objectDesc(STRING) + "Z)" + objectDesc(NATIVE_IMAGE)) - )); + this.rule("skin-texture-downloader.process-legacy-skin.v1", SKIN_TEXTURE_DOWNLOADER, "[769,772],[0x400000DE,0x4000010C]", context -> + this.replaceSkinTextureDownloaderProcessLegacySkin( + context, context.findMethod(SKIN_TEXTURE_DOWNLOADER, "lambda$downloadAndRegisterSkin$0", + "(" + objectDesc(PATH) + objectDesc(STRING) + "Z)" + objectDesc(NATIVE_IMAGE)))); // 1.21.9-pre1+ (1.21.9+) - modified |= this.applyIfMatches("[773,800],[804,0x40000000],[0x4000010D,]", "skin-texture-downloader.process-legacy-skin.v2", () -> replaceSkinTextureDownloaderProcessLegacySkin( - context, context.findMethod(SKIN_TEXTURE_DOWNLOADER, "lambda$downloadAndRegisterSkin$0", "(" + objectDesc(PATH) + objectDesc(CLIENT_ASSET_DOWNLOADED_TEXTURE) + "Z)" + objectDesc(NATIVE_IMAGE)) - )); - return modified; + this.rule("skin-texture-downloader.process-legacy-skin.v2", SKIN_TEXTURE_DOWNLOADER, "[773,800],[804,0x40000000],[0x4000010D,]", context -> + this.replaceSkinTextureDownloaderProcessLegacySkin( + context, context.findMethod(SKIN_TEXTURE_DOWNLOADER, "lambda$downloadAndRegisterSkin$0", + "(" + objectDesc(PATH) + objectDesc(CLIENT_ASSET_DOWNLOADED_TEXTURE) + "Z)" + objectDesc(NATIVE_IMAGE)))); } private boolean replaceSkinTextureDownloaderProcessLegacySkin(ClassTransformationContext context, MethodNode methodNode) { @@ -113,64 +119,10 @@ public final class SkinTexturePatch extends PatchSupport { } MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (methodInsnNode.getOpcode() != INVOKESTATIC || !owner.equals(methodInsnNode.owner) || !originalName.equals(methodInsnNode.name) || !originalDesc.equals(methodInsnNode.desc)) { - continue; + if (methodInsnNode.getOpcode() == INVOKESTATIC && owner.equals(methodInsnNode.owner) && originalName.equals(methodInsnNode.name) && originalDesc.equals(methodInsnNode.desc)) { + this.replaceInstructionSafely(context, methodNode, instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_BUFFER, "processLegacySkin", originalDesc, false)); + modified = true; } - - methodNodeSet(methodNode, instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_BUFFER, "processLegacySkin", originalDesc, false)); - modified = true; - } - return modified; - } - - private boolean replaceHttpTextureProcessLegacySkin(ClassTransformationContext context, MethodNode load) { - if (load == null) { - return false; - } - - boolean modified = false; - String owner = context.remapClassName(HTTP_TEXTURE); - String originalName = context.remapMethodName(HTTP_TEXTURE, "processLegacySkin", "(" + objectDesc(NATIVE_IMAGE) + ")" + objectDesc(NATIVE_IMAGE)); - String imageDesc = context.remapMethodDescriptor("(" + objectDesc(NATIVE_IMAGE) + ")" + objectDesc(NATIVE_IMAGE)); - String replacementDesc = context.remapMethodDescriptor("(" + objectDesc(NATIVE_IMAGE) + objectDesc(RUNNABLE) + objectDesc(FUNCTION) + ")" + objectDesc(NATIVE_IMAGE)); - String processTaskField = context.remapFieldName(HTTP_TEXTURE, "onDownloaded"); - - for (AbstractInsnNode instruction : load.instructions.toArray()) { - if (!(instruction instanceof MethodInsnNode)) { - continue; - } - - MethodInsnNode methodInsnNode = (MethodInsnNode) instruction; - if (!owner.equals(methodInsnNode.owner) || !originalName.equals(methodInsnNode.name) || !imageDesc.equals(methodInsnNode.desc)) { - continue; - } - - boolean staticProcessLegacySkin = methodInsnNode.getOpcode() == INVOKESTATIC; - InsnList injection = new InsnList(); - int implementationHandleTag; - String functionFactoryDesc; - if (staticProcessLegacySkin) { - injection.add(new VarInsnNode(ALOAD, 0)); - injection.add(new FieldInsnNode(GETFIELD, owner, processTaskField, objectDesc(RUNNABLE))); - implementationHandleTag = H_INVOKESTATIC; - functionFactoryDesc = "()" + objectDesc(FUNCTION); - } else { - injection.add(new InsnNode(SWAP)); - injection.add(new FieldInsnNode(GETFIELD, owner, processTaskField, objectDesc(RUNNABLE))); - injection.add(new VarInsnNode(ALOAD, 0)); - implementationHandleTag = H_INVOKEVIRTUAL; - functionFactoryDesc = "(" + objectDesc(owner) + ")" + objectDesc(FUNCTION); - } - injection.add(new InvokeDynamicInsnNode( - "apply", functionFactoryDesc, - new Handle(H_INVOKESTATIC, LAMBDA_METAFACTORY, "metafactory", "(" + objectDesc(METHOD_HANDLES_LOOKUP) + objectDesc(STRING) + objectDesc(METHOD_TYPE) + objectDesc(METHOD_TYPE) + objectDesc(METHOD_HANDLE) + objectDesc(METHOD_TYPE) + ")" + objectDesc(CALL_SITE), false), - Type.getType("(" + objectDesc(OBJECT) + ")" + objectDesc(OBJECT)), - new Handle(implementationHandleTag, owner, originalName, imageDesc, false), - Type.getType(imageDesc) - )); - load.instructions.insertBefore(instruction, injection); - methodNodeSet(load, instruction, new MethodInsnNode(INVOKESTATIC, FAKE_SKIN_BUFFER, "processLegacySkin", replacementDesc, false)); - modified = true; } return modified; } diff --git a/Bootstrap/Core/src/main/resources/META-INF/services/customskinloader.bootstrap.transformer.TargetedClassTransformer b/Bootstrap/Core/src/main/resources/META-INF/services/customskinloader.bootstrap.transformer.TransformationRuleProvider similarity index 100% rename from Bootstrap/Core/src/main/resources/META-INF/services/customskinloader.bootstrap.transformer.TargetedClassTransformer rename to Bootstrap/Core/src/main/resources/META-INF/services/customskinloader.bootstrap.transformer.TransformationRuleProvider diff --git a/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/MixinConfigPlugin.java b/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/MixinConfigPlugin.java index 6ac8277..f572961 100644 --- a/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/MixinConfigPlugin.java +++ b/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/MixinConfigPlugin.java @@ -9,8 +9,11 @@ import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin; import org.spongepowered.asm.mixin.extensibility.IMixinInfo; public final class MixinConfigPlugin implements IMixinConfigPlugin { + private String mixinPackage; + @Override public void onLoad(String mixinPackage) { + this.mixinPackage = mixinPackage + "."; TransformerBootstrap.initialize(); } @@ -27,7 +30,7 @@ public final class MixinConfigPlugin implements IMixinConfigPlugin { @Override public void acceptTargets(Set myTargets, Set otherTargets) { // This is the last stable point before postInitialise/validation, so reflected target injection is still visible downstream. - TransformerBootstrap.applyPendingMixinTargets(this); + TransformerBootstrap.applyMixinTargets(this.mixinPackage); } @Override @@ -37,11 +40,11 @@ public final class MixinConfigPlugin implements IMixinConfigPlugin { @Override public void preApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) { - + TransformerBootstrap.transformTargetClass(targetClassName, targetClass); } @Override public void postApply(String targetClassName, ClassNode targetClass, String mixinClassName, IMixinInfo mixinInfo) { - TransformerBootstrap.transformTargetClass(targetClassName, targetClass); + } } diff --git a/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/TransformerBootstrap.java b/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/TransformerBootstrap.java index d0119d1..ffe7c66 100644 --- a/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/TransformerBootstrap.java +++ b/Bootstrap/FabricV1/src/main/java/customskinloader/bootstrap/fabric/v1/TransformerBootstrap.java @@ -4,7 +4,6 @@ import java.lang.reflect.Field; import java.lang.reflect.Method; import java.nio.file.Path; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; @@ -14,12 +13,12 @@ import customskinloader.bootstrap.ModLoaderInfo; import customskinloader.bootstrap.installer.CommonJarInstaller; import customskinloader.bootstrap.transformer.ClassTransformationReport; import customskinloader.bootstrap.transformer.TransformerBootstrapSupport; +import customskinloader.bootstrap.util.ReflectionUtils; import net.fabricmc.loader.api.FabricLoader; import net.fabricmc.loader.impl.launch.FabricLauncherBase; import org.apache.logging.log4j.Logger; import org.objectweb.asm.tree.ClassNode; import org.spongepowered.asm.mixin.extensibility.IMixinConfig; -import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin; import org.spongepowered.asm.mixin.extensibility.IMixinInfo; import org.spongepowered.asm.mixin.transformer.ClassInfo; import org.spongepowered.asm.mixin.transformer.Config; @@ -27,8 +26,6 @@ import org.spongepowered.asm.mixin.transformer.Config; final class TransformerBootstrap { private static final Logger LOGGER = BootstrapLogger.LOGGER; private static final TransformerBootstrapSupport SUPPORT = new TransformerBootstrapSupport(TransformerBootstrap.class, "intermediary"); - private static final Object LOCK = new Object(); - private static final List PENDING_MIXIN_TARGETS = new ArrayList<>(); private static final String DUMMY_MIXIN = "customskinloader.bootstrap.fabric.v1.mixin.DummyMixin"; private TransformerBootstrap() { @@ -36,21 +33,8 @@ final class TransformerBootstrap { public static void initialize() { LOGGER.info("Initializing CustomSkinLoader Bootstrap for Fabric"); - publishModLoaderInfo(); - releaseRuntimeArtifacts(); - int targetCount = 0; - for (String targetClassName : SUPPORT.collectTargetClassNames()) { - registerMixinTarget(DUMMY_MIXIN, targetClassName.replace('/', '.')); - targetCount++; - } - LOGGER.info("Initialized CustomSkinLoader Bootstrap for Fabric with " + targetCount + " reflected Mixin target(s)"); - } - - private static void publishModLoaderInfo() { ModLoaderInfo.publish("Fabric", FabricLoader.getInstance().getModContainer("fabricloader").map(m -> m.getMetadata().getVersion().getFriendlyString()).orElse("unknown")); - } - private static void releaseRuntimeArtifacts() { try { Path commonJar = CommonJarInstaller.releaseCommonJar(FabricLoader.getInstance().getGameDir(), "intermediary"); FabricLauncherBase.getLauncher().addToClassPath(commonJar, "customskinloader."); @@ -61,133 +45,88 @@ final class TransformerBootstrap { } } - public static void registerMixinTarget(String mixinClassName, String targetClassName) { - synchronized (LOCK) { - PENDING_MIXIN_TARGETS.add(new PendingMixinTarget(mixinClassName, targetClassName)); - LOGGER.debug("Queued Fabric Mixin target " + targetClassName + " for " + mixinClassName); - } - } - - public static void applyPendingMixinTargets(IMixinConfigPlugin plugin) { - synchronized (LOCK) { - if (PENDING_MIXIN_TARGETS.isEmpty()) { - return; - } - - try { - IMixinConfig mixinConfig = findOwningMixinConfig(plugin); - int appliedTargetCount = 0; - Iterator iterator = PENDING_MIXIN_TARGETS.iterator(); - while (iterator.hasNext()) { - PendingMixinTarget pendingTarget = iterator.next(); - applyMixinTarget(mixinConfig, pendingTarget.mixinClassName, pendingTarget.targetClassName); - iterator.remove(); - appliedTargetCount++; + @SuppressWarnings("unchecked") + public static void applyMixinTargets(String mixinPackage) { + try { + IMixinConfig mixinConfig = null; + Field allConfigsField = ReflectionUtils.findField(Config.class, "allConfigs"); + for (Object configHandle : ((Map) allConfigsField.get(null)).values()) { + IMixinConfig mixinConfig0 = ((Config) configHandle).getConfig(); + if (mixinPackage.equals(mixinConfig0.getMixinPackage())) { + mixinConfig = mixinConfig0; + break; } - LOGGER.info("Applied " + appliedTargetCount + " reflected Fabric Mixin target(s)"); - } catch (ReflectiveOperationException exception) { - LOGGER.error("Failed to append reflected targets to the current Fabric mixin config", exception); - throw new IllegalStateException("Failed to append reflected targets to the current Fabric mixin config", exception); } + if (mixinConfig == null) { + throw new IllegalStateException("Could not find the owning MixinConfig for " + mixinPackage); + } + + int appliedTargetCount = 0; + Class mixinConfigClass = ReflectionUtils.findClass("org.spongepowered.asm.mixin.transformer.MixinConfig"); + Class mixinInfoClass = ReflectionUtils.findClass("org.spongepowered.asm.mixin.transformer.MixinInfo"); + + Field mixinsField = ReflectionUtils.findField(mixinConfigClass, "mixins"); + Field targetClassNamesField = ReflectionUtils.findField(mixinInfoClass, "targetClassNames"); + Field targetClassesField = ReflectionUtils.findField(mixinInfoClass, "targetClasses"); + Field mixinMappingField = ReflectionUtils.findField(mixinConfigClass, "mixinMapping"); + Field unhandledTargetsField = ReflectionUtils.findField(mixinConfigClass, "unhandledTargets"); + + Method addMixinMethod = ReflectionUtils.findMethod(ClassInfo.class, "addMixin", mixinInfoClass); + + for (String targetClassName : SUPPORT.getTargetClassNames()) { + boolean applied = false; + for (Object mixinInfo : (List) mixinsField.get(mixinConfig)) { + String currentMixinName = ((IMixinInfo) mixinInfo).getClassName(); + if (DUMMY_MIXIN.equals(currentMixinName)) { + String targetBinaryName = targetClassName.replace('/', '.'); + String targetInternalName = targetClassName.replace('.', '/'); + + List targetClassNames = (List) targetClassNamesField.get(mixinInfo); + if (targetClassNames.contains(targetInternalName)) { + applied = true; + break; + } + + ClassInfo targetClassInfo = ClassInfo.forName(targetInternalName); + if (targetClassInfo == null) { + throw new IllegalStateException("Could not resolve target ClassInfo for " + targetInternalName); + } + + addMixinMethod.invoke(targetClassInfo, mixinInfo); + List targetClasses = (List) targetClassesField.get(mixinInfo); + targetClasses.add(targetClassInfo); + targetClassNames.add(targetInternalName); + + Map> mixinMapping = (Map>) mixinMappingField.get(mixinConfig); + List mappedMixins = mixinMapping.computeIfAbsent(targetBinaryName, k -> new ArrayList<>()); + if (!mappedMixins.contains(mixinInfo)) { + mappedMixins.add(mixinInfo); + } + + ((Set) unhandledTargetsField.get(mixinConfig)).add(targetBinaryName); + applied = true; + break; + } + } + + if (!applied) { + throw new IllegalStateException("Could not find mixin " + DUMMY_MIXIN + " in the current config"); + } + + LOGGER.debug("Applied Fabric Mixin target " + targetClassName); + appliedTargetCount++; + } + LOGGER.info("Applied " + appliedTargetCount + " reflected Fabric Mixin target(s)"); + } catch (ReflectiveOperationException exception) { + LOGGER.error("Failed to append reflected targets to the current Fabric mixin config", exception); + throw new IllegalStateException("Failed to append reflected targets to the current Fabric mixin config", exception); } } public static void transformTargetClass(String targetClassName, ClassNode targetClass) { - ClassTransformationReport report = SUPPORT.transformClassNode(targetClassName, targetClass); - ClassNode transformedNode = report.getTransformedClassNode(); - if (transformedNode != targetClass) { - TransformerBootstrapSupport.copyClassNode(transformedNode, targetClass); - } + ClassTransformationReport report = SUPPORT.transform(targetClassName, targetClass); if (report.isModified()) { - LOGGER.info("Transformed Fabric target " + targetClassName + " with " + report.getAppliedTransformerNames()); - } - } - - private static IMixinConfig findOwningMixinConfig(IMixinConfigPlugin plugin) throws ReflectiveOperationException { - Field allConfigsField = Config.class.getDeclaredField("allConfigs"); - allConfigsField.setAccessible(true); - - for (Object configHandle : ((Map) allConfigsField.get(null)).values()) { - IMixinConfig mixinConfig = ((Config) configHandle).getConfig(); - if (mixinConfig.getPlugin() == plugin) { - return mixinConfig; - } - } - - throw new IllegalStateException("Could not find the owning MixinConfig for " + plugin.getClass().getName()); - } - - @SuppressWarnings("unchecked") - private static void applyMixinTarget(IMixinConfig mixinConfig, String mixinClassName, String targetClassName) throws ReflectiveOperationException { - IMixinInfo mixinInfo = findMixinInfo(mixinConfig, mixinClassName); - String targetBinaryName = targetClassName.replace('/', '.'); - String targetInternalName = targetClassName.replace('.', '/'); - - List targetClassNames = (List) getField(mixinInfo, "targetClassNames"); - if (targetClassNames.contains(targetInternalName)) { - return; - } - - ClassInfo targetClassInfo = ClassInfo.forName(targetInternalName); - if (targetClassInfo == null) { - throw new IllegalStateException("Could not resolve target ClassInfo for " + targetInternalName); - } - - Method addMixin = ClassInfo.class.getDeclaredMethod("addMixin", Class.forName("org.spongepowered.asm.mixin.transformer.MixinInfo")); - addMixin.setAccessible(true); - addMixin.invoke(targetClassInfo, mixinInfo); - - List targetClasses = (List) getField(mixinInfo, "targetClasses"); - targetClasses.add(targetClassInfo); - targetClassNames.add(targetInternalName); - - Map> mixinMapping = (Map>) getField(mixinConfig, "mixinMapping"); - List mappedMixins = mixinMapping.computeIfAbsent(targetBinaryName, k -> new ArrayList<>()); - if (!mappedMixins.contains(mixinInfo)) { - mappedMixins.add(mixinInfo); - } - - ((Set) getField(mixinConfig, "unhandledTargets")).add(targetBinaryName); - } - - @SuppressWarnings("unchecked") - private static IMixinInfo findMixinInfo(IMixinConfig mixinConfig, String mixinClassName) throws ReflectiveOperationException { - for (IMixinInfo mixinInfo : (List) getField(mixinConfig, "mixins")) { - String currentMixinName = mixinInfo.getClassName(); - if (mixinClassName.equals(currentMixinName)) { - return mixinInfo; - } - } - - throw new IllegalStateException("Could not find mixin " + mixinClassName + " in the current config"); - } - - private static Object getField(Object instance, String fieldName) throws ReflectiveOperationException { - Field field = findField(instance.getClass(), fieldName); - field.setAccessible(true); - return field.get(instance); - } - - private static Field findField(Class type, String fieldName) throws NoSuchFieldException { - Class currentType = type; - while (currentType != null) { - try { - return currentType.getDeclaredField(fieldName); - } catch (NoSuchFieldException exception) { - currentType = currentType.getSuperclass(); - } - } - - throw new NoSuchFieldException(fieldName); - } - - private static final class PendingMixinTarget { - private final String mixinClassName; - private final String targetClassName; - - private PendingMixinTarget(String mixinClassName, String targetClassName) { - this.mixinClassName = mixinClassName; - this.targetClassName = targetClassName; + LOGGER.info("Transformed Fabric target " + targetClassName + " with " + report.getAppliedRuleNames()); } } } diff --git a/Bootstrap/ForgeV1/src/main/java/customskinloader/bootstrap/forge/v1/TransformerBootstrap.java b/Bootstrap/ForgeV1/src/main/java/customskinloader/bootstrap/forge/v1/TransformerBootstrap.java index e8d8ade..b4d0b31 100644 --- a/Bootstrap/ForgeV1/src/main/java/customskinloader/bootstrap/forge/v1/TransformerBootstrap.java +++ b/Bootstrap/ForgeV1/src/main/java/customskinloader/bootstrap/forge/v1/TransformerBootstrap.java @@ -13,7 +13,6 @@ import customskinloader.bootstrap.transformer.TransformerBootstrapSupport; import net.minecraft.launchwrapper.LaunchClassLoader; import net.minecraftforge.fml.relauncher.FMLInjectionData; import org.apache.logging.log4j.Logger; -import org.objectweb.asm.tree.ClassNode; final class TransformerBootstrap { private static final Logger LOGGER = BootstrapLogger.LOGGER; @@ -39,16 +38,9 @@ final class TransformerBootstrap { } public static byte[] transform(String className, byte[] classBytecode) { - SUPPORT.ensureTransformersLoaded(); - - if (!SUPPORT.hasApplicableTransformers(className)) { - return classBytecode; - } - - ClassNode classNode = TransformerBootstrapSupport.toClassNode(classBytecode); - ClassTransformationReport report = SUPPORT.transformClassNode(className, classNode); + ClassTransformationReport report = SUPPORT.transform(className, classBytecode); if (report.isModified()) { - LOGGER.info("Transformed Forge v1 target " + className + " with " + report.getAppliedTransformerNames()); + LOGGER.info("Transformed Forge v1 target " + className + " with " + report.getAppliedRuleNames()); } return report.isModified() ? report.getTransformedBytecode() : classBytecode; } diff --git a/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformationService.java b/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformationService.java index 842522f..ff5c84e 100644 --- a/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformationService.java +++ b/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformationService.java @@ -3,6 +3,7 @@ package customskinloader.bootstrap.forge.v2; import java.net.URISyntaxException; import java.nio.file.Path; import java.nio.file.Paths; +import java.util.Collections; import java.util.List; import java.util.Set; @@ -55,8 +56,7 @@ public final class TransformationService implements ITransformationService { @Override public List transformers() { - List transformers = TransformerBootstrap.buildTransformers(); - LOGGER.info("Provided " + transformers.size() + " CustomSkinLoader ModLauncher transformer(s)"); - return transformers; + LOGGER.info("Providing CustomSkinLoader ModLauncher transformer"); + return Collections.singletonList(new TransformerBootstrap()); } } diff --git a/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformerBootstrap.java b/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformerBootstrap.java index 0fad655..1aca68a 100644 --- a/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformerBootstrap.java +++ b/Bootstrap/ForgeV2/src/main/java/customskinloader/bootstrap/forge/v2/TransformerBootstrap.java @@ -1,9 +1,7 @@ package customskinloader.bootstrap.forge.v2; -import java.util.ArrayList; import java.util.Collections; import java.util.LinkedHashSet; -import java.util.List; import java.util.Objects; import java.util.Set; @@ -21,7 +19,7 @@ import net.minecraftforge.fml.loading.FMLLoader; import org.apache.logging.log4j.Logger; import org.objectweb.asm.tree.ClassNode; -final class TransformerBootstrap { +final class TransformerBootstrap implements ITransformer { private static final Logger LOGGER = BootstrapLogger.LOGGER; private static final TransformerBootstrapSupport SUPPORT = new TransformerBootstrapSupport(TransformerBootstrap.class, // official: neoforge 1.20.2-20.2.3 ~ 1.21.3-21.3.97 @@ -29,9 +27,6 @@ final class TransformerBootstrap { Launcher.INSTANCE.environment().findLaunchHandler("forgeclient") .map(handle -> handle.getClass().getName().startsWith("net.neoforged.")).orElse(false) ? "official" : "srg"); - private TransformerBootstrap() { - } - public static void publishModLoaderInfo() { try { Object argumentHandler = ReflectionUtils.findField(Launcher.class, "argumentHandler").get(Launcher.INSTANCE); @@ -57,61 +52,44 @@ final class TransformerBootstrap { } } - public static List buildTransformers() { - List transformers = new ArrayList<>(); - for (String targetClassName : SUPPORT.collectTargetClassNames()) { - transformers.add(new ModLauncherClassTransformer(targetClassName)); - LOGGER.debug("Created ModLauncher transformer for " + targetClassName); - } + private final Set targets; - return Collections.unmodifiableList(transformers); + TransformerBootstrap() { + Set transformerTargets = new LinkedHashSet<>(); + for (String targetClassName : SUPPORT.getTargetClassNames()) { + transformerTargets.add(ITransformer.Target.targetClass(targetClassName)); + } + this.targets = Collections.unmodifiableSet(transformerTargets); + LOGGER.info("Created one ModLauncher transformer for " + this.targets.size() + " target class(es)"); } - private static ClassNode transformClassNode(String internalClassName, ClassNode inputClassNode) { - ClassTransformationReport report = SUPPORT.transformClassNode(internalClassName, inputClassNode); - if (!report.isModified() || report.getTransformedClassNode() == null) { - return inputClassNode; + @Override + public ClassNode transform(ClassNode input, ITransformerVotingContext context) { + String internalClassName = input.name; + ClassTransformationReport report = SUPPORT.transform(internalClassName, input); + if (report.isModified()) { + LOGGER.info("Transformed ModLauncher target " + internalClassName + " with " + report.getAppliedRuleNames()); } - - LOGGER.info("Transformed ModLauncher target " + internalClassName + " with " + report.getAppliedTransformerNames()); return report.getTransformedClassNode(); } - private static final class ModLauncherClassTransformer implements ITransformer { - private final String targetClassName; - private final Set targets; + @Override + public TransformerVoteResult castVote(ITransformerVotingContext context) { + return TransformerVoteResult.YES; + } - private ModLauncherClassTransformer(String targetClassName) { - this.targetClassName = targetClassName; + @Override + public Set targets() { + return this.targets; + } - Set transformerTargets = new LinkedHashSet<>(); - transformerTargets.add(ITransformer.Target.targetClass(targetClassName)); - this.targets = Collections.unmodifiableSet(transformerTargets); - } + // NeoForge + public cpw.mods.modlauncher.api.TargetType getTargetType() { + return cpw.mods.modlauncher.api.TargetType.CLASS; + } - @Override - public ClassNode transform(ClassNode input, ITransformerVotingContext context) { - return transformClassNode(this.targetClassName, input); - } - - @Override - public TransformerVoteResult castVote(ITransformerVotingContext context) { - return TransformerVoteResult.YES; - } - - @Override - public Set targets() { - return this.targets; - } - - // NeoForge - public cpw.mods.modlauncher.api.TargetType getTargetType() { - return cpw.mods.modlauncher.api.TargetType.CLASS; - } - - @Override - public String[] labels() { - return new String[] {"customskinloader:" + this.targetClassName.replace('/', '.')}; - } + @Override + public String[] labels() { + return new String[] {"customskinloader:bootstrap"}; } } diff --git a/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/ClassProcessorProviderImpl.java b/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/ClassProcessorProviderImpl.java index 2453d26..a190c44 100644 --- a/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/ClassProcessorProviderImpl.java +++ b/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/ClassProcessorProviderImpl.java @@ -15,6 +15,6 @@ public final class ClassProcessorProviderImpl implements ClassProcessorProvider // Always register the bridge processor so late transformer registrations can still be observed. LOGGER.info("Registering CustomSkinLoader Bootstrap NeoForge class processor"); ModLoaderInfo.publish("NeoForge", FMLLoader.getCurrent().getVersionInfo().neoForgeVersion()); - collector.add(TransformerBootstrap.createProcessor()); + collector.add(new TransformerBootstrap()); } } diff --git a/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/TransformerBootstrap.java b/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/TransformerBootstrap.java index c885f8f..d64b4db 100644 --- a/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/TransformerBootstrap.java +++ b/Bootstrap/NeoForgeV2/src/main/java/customskinloader/bootstrap/neoforge/v2/TransformerBootstrap.java @@ -10,63 +10,49 @@ import net.neoforged.neoforgespi.transformation.ClassProcessor; import net.neoforged.neoforgespi.transformation.ClassProcessorIds; import net.neoforged.neoforgespi.transformation.ProcessorName; import org.apache.logging.log4j.Logger; -import org.objectweb.asm.tree.ClassNode; -final class TransformerBootstrap { +final class TransformerBootstrap implements ClassProcessor { private static final Logger LOGGER = BootstrapLogger.LOGGER; private static final TransformerBootstrapSupport SUPPORT = new TransformerBootstrapSupport(TransformerBootstrap.class, "official"); private static final ProcessorName PROCESSOR_NAME = new ProcessorName("customskinloader", "bootstrap"); - private TransformerBootstrap() { - } - - public static ClassProcessor createProcessor() { - SUPPORT.ensureTransformersLoaded(); + TransformerBootstrap() { + SUPPORT.getTargetClassNames(); LOGGER.info("Created CustomSkinLoader Bootstrap NeoForge class processor"); - return new BootstrapClassProcessor(); } - private static ClassTransformationReport transformClassNode(String internalClassName, ClassNode inputClassNode) { - return SUPPORT.transformClassNode(internalClassName, inputClassNode); + @Override + public ProcessorName name() { + return PROCESSOR_NAME; } - private static final class BootstrapClassProcessor implements ClassProcessor { - @Override - public ProcessorName name() { - return PROCESSOR_NAME; + @Override + public Set runsBefore() { + return Collections.singleton(ClassProcessorIds.MIXIN); + } + + @Override + public boolean handlesClass(SelectionContext context) { + // The shared framework currently targets concrete classes only, so we skip synthetic empty definitions. + return !context.empty() && SUPPORT.getTargetClassNames().contains(context.type().getInternalName()); + } + + @Override + public ComputeFlags processClass(TransformationContext context) { + ClassTransformationReport report = SUPPORT.transform(context.type().getInternalName(), context.node()); + if (!report.isModified()) { + return ComputeFlags.NO_REWRITE; } - @Override - public Set runsAfter() { - // Run after the default simple-processor group so the shared framework sees post-Mixin bytecode. - return Collections.singleton(ClassProcessorIds.SIMPLE_PROCESSORS_GROUP); + for (String ruleName : report.getAppliedRuleNames()) { + context.audit("customskinloader.bootstrap", ruleName); } + LOGGER.info("Transformed NeoForge target " + context.type().getInternalName() + " with " + report.getAppliedRuleNames()); + return ComputeFlags.COMPUTE_FRAMES; + } - @Override - public boolean handlesClass(SelectionContext context) { - // The shared framework currently targets concrete classes only, so we skip synthetic empty definitions. - return !context.empty() && SUPPORT.hasApplicableTransformers(context.type().getInternalName()); - } - - @Override - public ComputeFlags processClass(TransformationContext context) { - ClassTransformationReport report = transformClassNode(context.type().getInternalName(), context.node()); - if (!report.isModified()) { - return ComputeFlags.NO_REWRITE; - } - - TransformerBootstrapSupport.copyClassNode(report.getTransformedClassNode(), context.node()); - for (String transformerName : report.getAppliedTransformerNames()) { - context.audit("customskinloader.bootstrap", transformerName); - } - - LOGGER.info("Transformed NeoForge target " + context.type().getInternalName() + " with " + report.getAppliedTransformerNames()); - return ComputeFlags.COMPUTE_FRAMES; - } - - @Override - public OrderingHint orderingHint() { - return OrderingHint.LATE; - } + @Override + public OrderingHint orderingHint() { + return OrderingHint.EARLY; } } diff --git a/Common/src/main/java/customskinloader/fake/FakeSkinBuffer.java b/Common/src/main/java/customskinloader/fake/FakeSkinBuffer.java index 2c0fd88..70ac839 100644 --- a/Common/src/main/java/customskinloader/fake/FakeSkinBuffer.java +++ b/Common/src/main/java/customskinloader/fake/FakeSkinBuffer.java @@ -38,14 +38,16 @@ public class FakeSkinBuffer implements FakeHttpTextureProcessor { * 19w38a ~ 24w45a * Invoked from {@link HttpTexture#loadTexture(InputStream)} */ - public static NativeImage processLegacySkin(NativeImage image, Runnable processTask, Function processLegacySkin) { - if (processTask instanceof FakeHttpTextureProcessor) { - return ((FakeHttpTextureProcessor) processTask).process(image); - } else if (processLegacySkin != null) { - return processLegacySkin.apply(image); - } else { - return image; - } + public static boolean shouldProcessLegacySkin(Runnable processTask) { + return processTask instanceof FakeHttpTextureProcessor; + } + + /** + * 19w38a ~ 24w45a + * Invoked from {@link HttpTexture#loadTexture(InputStream)} + */ + public static NativeImage processLegacySkin(NativeImage image, Runnable processTask) { + return ((FakeHttpTextureProcessor) processTask).process(image); } //parseUserSkin for 1.13+ diff --git a/Common/src/main/java/customskinloader/fake/FakeSkinManager.java b/Common/src/main/java/customskinloader/fake/FakeSkinManager.java index 3ea5c8a..155f438 100644 --- a/Common/src/main/java/customskinloader/fake/FakeSkinManager.java +++ b/Common/src/main/java/customskinloader/fake/FakeSkinManager.java @@ -1,18 +1,9 @@ package customskinloader.fake; -import java.awt.image.BufferedImage; -import java.io.File; -import java.nio.file.Path; -import java.util.Map; -import java.util.UUID; -import java.util.concurrent.Executor; -import java.util.function.Supplier; - import com.mojang.authlib.GameProfile; import com.mojang.authlib.SignatureState; import com.mojang.authlib.minecraft.MinecraftProfileTexture; import com.mojang.authlib.minecraft.MinecraftProfileTextures; -import com.mojang.authlib.minecraft.MinecraftSessionService; import com.mojang.authlib.properties.Property; import com.mojang.blaze3d.platform.NativeImage; import customskinloader.CustomSkinLoader; @@ -24,6 +15,14 @@ import net.minecraft.client.resources.SkinManager; import net.minecraft.client.resources.SkinManager$CacheKey; import net.minecraft.server.Services; +import java.awt.image.BufferedImage; +import java.io.File; +import java.nio.file.Path; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.Executor; +import java.util.function.Supplier; + public class FakeSkinManager { /** * 1.20.1- @@ -51,7 +50,7 @@ public class FakeSkinManager { * 1.20.1- * Invoked from {@link SkinManager#registerSkins(GameProfile, SkinManager$SkinTextureCallback, boolean)} */ - public static void loadProfileTextures(Runnable runnable) { + public static void loadProfileTextures(Object executor, Runnable runnable) { CustomSkinLoader.loadProfileTextures(runnable); } @@ -67,7 +66,7 @@ public class FakeSkinManager { * 1.20.1- * Invoked from {@link SkinManager#lambda$registerSkins$4(GameProfile, boolean, SkinManager$SkinTextureCallback)} */ - public static Map getUserProfile(MinecraftSessionService sessionService, GameProfile profile, boolean requireSecure) { + public static Map getUserProfile(Object sessionService, GameProfile profile, boolean requireSecure) { return ModelManager0.fromUserProfile(CustomSkinLoader.loadProfile(profile)); } @@ -83,7 +82,7 @@ public class FakeSkinManager { * 23w31a ~ 23w41a * Invoked from {@link SkinManager$1#lambda$load$0(MinecraftSessionService, GameProfile)} */ - public static Map loadSkinFromCache(MinecraftSessionService sessionService, GameProfile profile, boolean requireSecure) { + public static Map loadSkinFromCache(Object sessionService, GameProfile profile, boolean requireSecure) { return getUserProfile(sessionService, profile, requireSecure); } @@ -94,11 +93,11 @@ public class FakeSkinManager { * 25w34a+ * Invoked from {@link SkinManager$1#lambda$load$0(SkinManager$CacheKey, Services)} */ - public static Object loadSkinFromCache(MinecraftSessionService sessionService, Property property, SkinManager$CacheKey cacheKey) { + public static Object loadSkinFromCache(Object textures, SkinManager$CacheKey cacheKey) { if (cacheKey instanceof FakeCacheKey) { - return FakeCacheKey.createMinecraftProfileTextures(loadSkinFromCache(sessionService, ((FakeCacheKey) cacheKey).profile(), false)); + return FakeCacheKey.createMinecraftProfileTextures(loadSkinFromCache(null, ((FakeCacheKey) cacheKey).profile(), false)); } - return sessionService.unpackTextures(property); + return textures; } public static class BaseBuffer implements FakeHttpTextureProcessor { @@ -173,7 +172,7 @@ public class FakeSkinManager { * Invoked from {@link SkinManager#get(GameProfile)} */ public static SkinManager$CacheKey createFakeCacheKey(UUID uuid, Property property, GameProfile profile) { - return new FakeCacheKey(uuid, property == null ? new Property(null, null) : property, profile); + return new FakeCacheKey(uuid, property == null ? new Property("", "") : property, profile); } public static Object createMinecraftProfileTextures(Map textures) { diff --git a/Common/src/main/java/customskinloader/loader/GameProfileLoader.java b/Common/src/main/java/customskinloader/loader/GameProfileLoader.java index 234a35c..aecf021 100644 --- a/Common/src/main/java/customskinloader/loader/GameProfileLoader.java +++ b/Common/src/main/java/customskinloader/loader/GameProfileLoader.java @@ -14,7 +14,6 @@ import com.mojang.authlib.GameProfile; import com.mojang.authlib.minecraft.MinecraftProfileTexture; import com.mojang.authlib.properties.Property; import com.mojang.authlib.properties.PropertyMap; -import com.mojang.authlib.yggdrasil.response.MinecraftTexturesPayload; import com.mojang.util.UUIDTypeAdapter; import customskinloader.CustomSkinLoader; import customskinloader.config.SkinSiteProfile; @@ -101,10 +100,14 @@ public class GameProfileLoader implements ICustomSkinLoaderPlugin, ProfileLoader if (result == null) { return Maps.newHashMap(); } - Map textures = TextureUtil.AuthlibField.MINECRAFT_TEXTURES_PAYLOAD_TEXTURES.get(result); + Map textures = result.textures; if (textures == null) { return Maps.newHashMap(); } return textures; } + + public static class MinecraftTexturesPayload { + public Map textures; + } } diff --git a/Common/src/main/java/customskinloader/loader/MojangAPILoader.java b/Common/src/main/java/customskinloader/loader/MojangAPILoader.java index 16d3e9d..2843e06 100644 --- a/Common/src/main/java/customskinloader/loader/MojangAPILoader.java +++ b/Common/src/main/java/customskinloader/loader/MojangAPILoader.java @@ -6,12 +6,10 @@ import java.util.Map; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; -import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.mojang.authlib.GameProfile; import com.mojang.authlib.minecraft.MinecraftProfileTexture; import com.mojang.authlib.properties.PropertyMap; -import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse; import customskinloader.CustomSkinLoader; import customskinloader.config.SkinSiteProfile; import customskinloader.plugin.ICustomSkinLoaderPlugin; @@ -86,7 +84,7 @@ public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.I CustomSkinLoader.logger.info("Profile not found.(" + username + "'s profile not found.)"); return null; } - PropertyMap propertyMap = TextureUtil.AuthlibField.MINECRAFT_PROFILE_PROPERTIES_RESPONSE_PROPERTIES.get(fillProfile(ssp.sessionRoot, newProfile)); + PropertyMap propertyMap = fillProfile(ssp.sessionRoot, newProfile).properties; if (propertyMap != null) { Map map = GameProfileLoader.getTextures(propertyMap); if (!map.isEmpty()) { @@ -116,7 +114,7 @@ public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.I return null; } - UUID id = TextureUtil.AuthlibField.MINECRAFT_PROFILE_PROPERTIES_RESPONSE_ID.get(profiles[0]); + UUID id = profiles[0].id; if (id == null) { return null; } @@ -135,14 +133,14 @@ public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.I if (profile == null) { return null; } - UUID id = TextureUtil.AuthlibField.MINECRAFT_PROFILE_PROPERTIES_RESPONSE_ID.get(profile); + UUID id = profile.id; return standard ? id.toString() : TextureUtil.fromUUID(id); } //UUID -> Profile public static MinecraftProfilePropertiesResponse fillProfile(String sessionRoot, MinecraftProfilePropertiesResponse profile) { //Doc (https://minecraft.wiki/w/Mojang_API#Query_player's_skin_and_cape) - HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(new HttpRequestUtil.HttpRequest(sessionRoot + "session/minecraft/profile/" + TextureUtil.fromUUID(TextureUtil.AuthlibField.MINECRAFT_PROFILE_PROPERTIES_RESPONSE_ID.get(profile))).setCacheTime(90)); + HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(new HttpRequestUtil.HttpRequest(sessionRoot + "session/minecraft/profile/" + TextureUtil.fromUUID(profile.id)).setCacheTime(90)); if (StringUtils.isEmpty(responce.content)) { return profile; } @@ -179,4 +177,9 @@ public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.I public static String getMojangSessionRoot() { return MOJANG_SESSION_ROOT.replace("{DO_NOT_MODIFY}", ""); } + + public static class MinecraftProfilePropertiesResponse { + public UUID id; + public PropertyMap properties; + } } diff --git a/Common/src/main/java/customskinloader/utils/TextureUtil.java b/Common/src/main/java/customskinloader/utils/TextureUtil.java index 93bb67d..4fe0193 100644 --- a/Common/src/main/java/customskinloader/utils/TextureUtil.java +++ b/Common/src/main/java/customskinloader/utils/TextureUtil.java @@ -6,8 +6,6 @@ import java.util.UUID; import com.mojang.authlib.GameProfile; import com.mojang.authlib.properties.Property; -import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse; -import com.mojang.authlib.yggdrasil.response.MinecraftTexturesPayload; import customskinloader.CustomSkinLoader; import org.apache.commons.codec.binary.Base64; import org.apache.commons.io.FileUtils; @@ -43,10 +41,7 @@ public class TextureUtil { GAME_PROFILE_ID(GameProfile.class, "id"), GAME_PROFILE_NAME(GameProfile.class, "name"), GAME_PROFILE_PROPERTIES(GameProfile.class, "properties"), - PROPERTY_VALUE(Property.class, "value"), - MINECRAFT_PROFILE_PROPERTIES_RESPONSE_ID(MinecraftProfilePropertiesResponse.class, "id"), - MINECRAFT_PROFILE_PROPERTIES_RESPONSE_PROPERTIES(MinecraftProfilePropertiesResponse.class, "properties"), - MINECRAFT_TEXTURES_PAYLOAD_TEXTURES(MinecraftTexturesPayload.class, "textures"); + PROPERTY_VALUE(Property.class, "value"); private final Field field; @@ -67,14 +62,6 @@ public class TextureUtil { throw new RuntimeException(t); } } - - public void set(Object o, Object value) { - try { - this.field.set(o, value); - } catch (Throwable t) { - throw new RuntimeException(t); - } - } } public static String fromUUID(UUID value) { diff --git a/build.info.json b/build.info.json index 7f73170..cf5cbb2 100644 --- a/build.info.json +++ b/build.info.json @@ -1,7 +1,7 @@ { "mod_group": "customskinloader", "mod_name": "CustomSkinLoader", - "mod_version": "15.0.1", + "mod_version": "15.1", "edition": "Universal", "loaders": [ @@ -22,7 +22,7 @@ "1.19", "1.19.1", "1.19.2", "1.19.3", "1.19.4", "1.20", "1.20.1", "1.20.2", "1.20.3", "1.20.4", "1.20.5", "1.20.6", "1.21", "1.21.1", "1.21.2", "1.21.3", "1.21.4", "1.21.5", "1.21.6", "1.21.7", "1.21.8", "1.21.9", "1.21.10", "1.21.11", - "26.1", "26.1.1", "26.1.2", "26.2" + "26.1", "26.1.1", "26.1.2", "26.2", "26.3" ], "java": [ 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 25 diff --git a/gradle.properties b/gradle.properties index 3f460c3..9ac266c 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,8 +1,8 @@ build_type=beta -minecraft_version=26.2 -fabric_v1_version=0.19.3 +minecraft_version=26.3 +fabric_v1_version=0.19.5 forge_v1_version=14.23.5.2864 forge_v2_version=36.2.42 neoforge_v1_version=20.6.13-beta -neoforge_v2_version=26.2.0.1-beta +neoforge_v2_version=26.3.0.1-beta diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index b1b8ef56b44f16b14dc800fa8103a6d89abb526f..eddabd2eef8d94a5437d6168ff9c87a78ff725b3 100644 GIT binary patch delta 39079 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 F{Rc_uT_ykk delta 40101 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 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index df6a6ad..ad7845b 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-9.7.1-bin.zip networkTimeout=10000 retries=0 retryBackOffMs=500 diff --git a/gradlew b/gradlew index b9bb139..249efbb 100755 --- a/gradlew +++ b/gradlew @@ -20,7 +20,7 @@ ############################################################################## # -# Gradle start up script for POSIX generated by Gradle. +# gradlew start up script for POSIX generated by Gradle. # # Important for running: # @@ -29,7 +29,7 @@ # bash, then to run this script, type that shell name before the whole # command line, like: # -# ksh Gradle +# ksh gradlew # # Busybox and similar reduced shells will NOT work, because this script # requires all of these POSIX shell features: diff --git a/gradlew.bat b/gradlew.bat index 24c62d5..a51ec4f 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -19,7 +19,7 @@ @if "%DEBUG%"=="" @echo off @rem ########################################################################## @rem -@rem Gradle startup script for Windows +@rem gradlew startup script for Windows @rem @rem ########################################################################## @@ -72,7 +72,7 @@ echo location of your Java installation. 1>&2 -@rem Execute Gradle +@rem Execute gradlew @rem endlocal doesn't take effect until after the line is parsed and variables are expanded @rem which allows us to clear the local environment before executing the java command endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel