Fixes a regression with TFC. (#1822)

This commit is contained in:
Jason Mitchell authored and GitHub committed 2026-06-05 16:13:30 -07:00
1 parent b4dfdb8cc5
commit ceff04adba
2 files changed
+30 -35

No files matched your search

@@ -17,7 +17,6 @@ public class CeleritasBlockTransformer implements IClassTransformer {
public CeleritasBlockTransformer() {
this.inner = new CeleritasBlockTransform(AngelicaClientTweaker.isObfEnv());
this.exclusions = inner.getTransformerExclusions();
this.inner.setCeleritasSetting();
}
/**
@@ -31,16 +31,21 @@ public final class CeleritasBlockTransform implements Opcodes {
private static final Logger LOGGER = LogManager.getLogger("CeleritasBlockTransformer");
private static final String BlockClass = "net/minecraft/block/Block";
private static final String ThreadedBlockData = "com/gtnewhorizons/angelica/client/rendering/ThreadedBlockData";
/** All classes under <tt>net.minecraft.block.Block*</tt> are Block subclasses save for these. */
private static final String[] VanillaBlockExclusions = {
"net/minecraft/block/IGrowable",
"net/minecraft/block/ITileEntityProvider",
"net/minecraft/block/BlockEventData",
"net/minecraft/block/BlockSourceImpl",
"net/minecraft/block/material/"
};
private final Map<String, String> fieldNameToRedirect = new HashMap<>();
private final Set<String> blockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
private final Set<String> moddedBlockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
// Block subclass owners we shouldn't redirect because they shadow some fields we want to redirect
private final Set<String> blockSubclassExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>());
private final ClassConstantPoolParser cstPoolParser;
private final MethodHandle celeritasEnabledGetter;
private boolean isCeleritasEnabled;
public CeleritasBlockTransform(boolean isObf) {
final List<Pair<String, String>> mappings = ImmutableList.of(
Pair.of("minX", "field_149759_B"),
@@ -56,37 +61,30 @@ public final class CeleritasBlockTransform implements Opcodes {
}
this.cstPoolParser = new ClassConstantPoolParser(this.fieldNameToRedirect.keySet().toArray(new String[0]));
}
blockSubclasses.add(BlockClass);
try {
// Needed because the config is loaded in LaunchClassLoader, but we need to access it in the parent system loader.
final Class<?> angelicaConfig = Class.forName("com.gtnewhorizons.angelica.config.AngelicaConfig", true, Launch.classLoader);
celeritasEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableCeleritas", boolean.class);
} catch (ReflectiveOperationException e) {
throw new RuntimeException(e);
private boolean isVanillaBlockSubclass(String className) {
if (!className.startsWith(BlockClass)) {
return false;
}
}
public void setCeleritasSetting() {
isCeleritasEnabled = true;
}
private boolean isCeleritasEnabled() {
if (isCeleritasEnabled) return true;
try {
return (boolean) celeritasEnabledGetter.invokeExact();
} catch (Throwable e) {
throw new RuntimeException(e);
for (String exclusion : VanillaBlockExclusions) {
if (className.startsWith(exclusion)) {
return false;
}
}
return true;
}
// This method needs to be called for every class, including the ones we don't want to transform
private boolean isBlockSubclass(String className) {
return isVanillaBlockSubclass(className) || moddedBlockSubclasses.contains(className);
}
// This method needs to be called for every class, including the ones we don't want to transform.
// Vanilla blocks are recognized by name; only modded subclasses need tracking, and FML's
// EventSubscriptionTransformer guarantees a modded class's superclass loads first.
public void trackBlockSubclasses(String className, String superClassName) {
// It works because the deepest subclasses are always transformed first due to
// ForgeEventTransformer recursive superclass loading
if (blockSubclasses.contains(superClassName)) {
blockSubclasses.add(className);
if (!isVanillaBlockSubclass(className) && isBlockSubclass(superClassName)) {
moddedBlockSubclasses.add(className);
if (blockSubclassExclusions.contains(superClassName)) {
LOGGER.info("Class {} extends a class with shadowed block bounds fields and will be skipped from redirecting", className);
@@ -110,9 +108,6 @@ public final class CeleritasBlockTransform implements Opcodes {
/** @return Was the class changed? */
public boolean transformClassNode(String transformedName, ClassNode cn) {
if (!isCeleritasEnabled()) {
return false;
}
boolean changed = false;
if (BlockClass.equals(cn.name)) {
changed = cn.fields.removeIf(field -> fieldNameToRedirect.containsKey(field.name));
@@ -124,7 +119,8 @@ public final class CeleritasBlockTransform implements Opcodes {
}
private void trackBlockShadowingFields(ClassNode cn) {
if (blockSubclasses.contains(cn.name)) {
// Only modded subclasses can shadow; vanilla declares these fields solely in Block.
if (moddedBlockSubclasses.contains(cn.name)) {
for (FieldNode field : cn.fields) {
if (fieldNameToRedirect.containsKey(field.name)) {
LOGGER.info("Class '{}' shadows one or more block bounds fields, these accesses won't be redirected!", cn.name);
@@ -141,7 +137,7 @@ public final class CeleritasBlockTransform implements Opcodes {
for (AbstractInsnNode node = mn.instructions.getFirst(); node != null; node = node.getNext()) {
if ((node.getOpcode() == GETFIELD || node.getOpcode() == PUTFIELD) && node instanceof FieldInsnNode fNode) {
String newFieldName = fieldNameToRedirect.get(fNode.name);
if (newFieldName != null && blockSubclasses.contains(fNode.owner) && !blockSubclassExclusions.contains(fNode.owner)) {
if (newFieldName != null && isBlockSubclass(fNode.owner) && !blockSubclassExclusions.contains(fNode.owner)) {
if (LOG_SPAM) {
LOGGER.info("Redirecting Block.{} in {} to thread-safe wrapper", fNode.name, transformedName);
}