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 b1b8ef5..eddabd2 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ 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