Parallelizing CTMUtils (#1393)

This commit is contained in:
Yan Huang authored and GitHub committed 2026-02-23 20:21:35 +00:00
1 parent b38fafa831
commit f7eb86cdb6
1 file changed
+134 -95
@@ -7,8 +7,8 @@ import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.StampedLock;
import net.minecraft.block.Block;
import net.minecraft.util.IIcon;
@@ -33,19 +33,36 @@ public class CTMUtils {
private static final MCLogger logger = MCLogger.getLogger(MCLogger.Category.CONNECTED_TEXTURES, "CTM");
private static final List<TileOverride> allOverrides = new ArrayList<>();
private static final Map<Block, List<BlockStateMatcher>> blockOverrides = new IdentityHashMap<>();
private static final Map<String, List<TileOverride>> tileOverrides = new HashMap<>();
private static class Overrides {
private final List<TileOverride> all = new ArrayList<>();
private final Map<Block, List<BlockStateMatcher>> block = new IdentityHashMap<>();
private final Map<String, List<TileOverride>> tile = new HashMap<>();
}
private static Overrides overrides = new Overrides();
private static Overrides newOverrides = null;
private static TileLoader tileLoader;
private static TileOverride lastOverride;
private static final Lock lock = new ReentrantLock();
private static final StampedLock lock = new StampedLock();
private static final TileOverrideIterator.IJK ijkIterator = newIJKIterator();
private static final TileOverrideIterator.Metadata metadataIterator = newMetadataIterator();
private static class StateAndIterator {
private final TileOverrideIterator.IJK ijkIterator = CTMUtils.newIJKIterator();
private final TileOverrideIterator.Metadata metadataIterator = CTMUtils.newMetadataIterator();
private final BlockOrientation renderBlockState = new BlockOrientation();
private final int texturePackChangeCounter;
private static boolean haveBlockFace;
private static final BlockOrientation renderBlockState = new BlockOrientation();
public StateAndIterator() {
this.texturePackChangeCounter = 0;
}
public StateAndIterator(int texturePackChangeCounter) {
this.texturePackChangeCounter = texturePackChangeCounter;
}
}
private static final ThreadLocal<StateAndIterator> stateAndIterator = ThreadLocal.withInitial(StateAndIterator::new);
private static final AtomicInteger texturePackChangeCounter = new AtomicInteger(0);
static {
try {
@@ -61,7 +78,7 @@ public class CTMUtils {
@Override
public void beforeChange() {
lock.lock();
long stamp = lock.writeLock();
try {
RenderPassAPI.instance.clear();
try {
@@ -71,39 +88,39 @@ public class CTMUtils {
} catch (Exception e) {
e.printStackTrace();
}
renderBlockState.clear();
ijkIterator.clear();
metadataIterator.clear();
allOverrides.clear();
blockOverrides.clear();
tileOverrides.clear();
lastOverride = null;
RenderBlocksUtils.blankIcon = null;
tileLoader = new TileLoader("textures/blocks", logger);
RenderPassAPI.instance.refreshBlendingOptions();
logger.info("loading CTM overrides");
newOverrides = new Overrides();
if (MCPatcherForgeConfig.ConnectedTextures.standard || MCPatcherForgeConfig.ConnectedTextures.nonStandard) {
for (ResourceLocation resource : ResourceList.getInstance()
.listResources(TexturePackAPI.MCPATCHER_SUBDIR + "ctm", ".properties", true)) {
registerOverride(TileOverride.create(resource, tileLoader));
registerOverrideWithoutLock(newOverrides, TileOverride.create(resource, tileLoader));
}
}
for (ResourceLocation resource : BlendMethod.getAllBlankResources()) {
tileLoader.preloadTile(resource, false);
}
} finally {
lock.unlock();
lock.unlockWrite(stamp);
}
}
@Override
public void afterChange() {
lock.lock();
if (newOverrides == null) {
logger.error("CTM overrides were not initialized during texture pack change");
logger.error("Maybe beforeChange was not called, or threw an exception?");
return;
}
long stamp = lock.writeLock();
try {
for (TileOverride override : allOverrides) {
for (TileOverride override : newOverrides.all) {
override.registerIcons();
}
for (Map.Entry<Block, List<BlockStateMatcher>> entry : blockOverrides.entrySet()) {
for (Map.Entry<Block, List<BlockStateMatcher>> entry : newOverrides.block.entrySet()) {
for (BlockStateMatcher matcher : entry.getValue()) {
TileOverride override = (TileOverride) matcher.getData();
if (override.getRenderPass() >= 0) {
@@ -111,67 +128,90 @@ public class CTMUtils {
}
}
}
for (List<BlockStateMatcher> overrides : blockOverrides.values()) {
for (List<BlockStateMatcher> overrides : newOverrides.block.values()) {
overrides.sort((m1, m2) -> {
TileOverride o1 = (TileOverride) m1.getData();
TileOverride o2 = (TileOverride) m2.getData();
return o1.compareTo(o2);
});
}
for (List<TileOverride> overrides : tileOverrides.values()) {
for (List<TileOverride> overrides : newOverrides.tile.values()) {
Collections.sort(overrides);
}
setBlankResource();
setBlankResourceWithoutLock();
overrides = newOverrides;
newOverrides = null;
texturePackChangeCounter.getAndIncrement();
} finally {
lock.unlock();
lock.unlockWrite(stamp);
}
}
});
}
private static void clearBlockFace() {
haveBlockFace = false;
private static StateAndIterator getStateAndIterator() {
int globalTexturePackChangeCounter = texturePackChangeCounter.get();
StateAndIterator local = stateAndIterator.get();
if (local.texturePackChangeCounter < globalTexturePackChangeCounter) {
local = new StateAndIterator(globalTexturePackChangeCounter);
stateAndIterator.set(local);
}
return local;
}
private static IIcon getBlockIconWithoutLock(IIcon icon, Block block, IBlockAccess blockAccess,
int x, int y, int z, int face) {
StateAndIterator local = getStateAndIterator();
if (blockAccess != null && checkFace(face)) {
local.renderBlockState.setBlock(block, blockAccess, x, y, z);
local.renderBlockState.setFace(face);
TileOverride lastOverride = local.ijkIterator.go(local.renderBlockState, icon);
if (lastOverride != null) {
return skipDefaultRendering(block) ? RenderBlocksUtils.blankIcon : local.ijkIterator.getIcon();
}
}
return skipDefaultRendering(block) ? RenderBlocksUtils.blankIcon : icon;
}
private static IIcon getBlockIconWithoutLock(IIcon icon, Block block, int face, int metadata) {
StateAndIterator local = getStateAndIterator();
if (checkFace(face) && checkRenderType(block)) {
local.renderBlockState.setBlockMetadata(block, metadata, face);
TileOverride lastOverride = local.metadataIterator.go(local.renderBlockState, icon);
if (lastOverride != null) {
return local.metadataIterator.getIcon();
}
}
return icon;
}
public static IIcon getBlockIcon(IIcon icon, Block block, IBlockAccess blockAccess,
int x, int y, int z, int face) {
lock.lock();
try {
lastOverride = null;
if (blockAccess != null && checkFace(face)) {
if (!haveBlockFace) {
renderBlockState.setBlock(block, blockAccess, x, y, z);
renderBlockState.setFace(face);
}
lastOverride = ijkIterator.go(renderBlockState, icon);
if (lastOverride != null) {
icon = ijkIterator.getIcon();
}
long stamp = lock.tryOptimisticRead();
IIcon value = getBlockIconWithoutLock(icon, block, blockAccess, x, y, z, face);
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
value = getBlockIconWithoutLock(icon, block, blockAccess, x, y, z, face);
} finally {
lock.unlockRead(stamp);
}
clearBlockFace();
IIcon result = lastOverride == null && skipDefaultRendering(block) ? RenderBlocksUtils.blankIcon : icon;
return result;
} finally {
lock.unlock();
}
return value;
}
public static IIcon getBlockIcon(IIcon icon, Block block, int face, int metadata) {
lock.lock();
try {
lastOverride = null;
if (checkFace(face) && checkRenderType(block)) {
renderBlockState.setBlockMetadata(block, metadata, face);
lastOverride = metadataIterator.go(renderBlockState, icon);
if (lastOverride != null) {
icon = metadataIterator.getIcon();
}
long stamp = lock.tryOptimisticRead();
IIcon value = getBlockIconWithoutLock(icon, block, face, metadata);
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
value = getBlockIconWithoutLock(icon, block, face, metadata);
} finally {
lock.unlockRead(stamp);
}
return icon;
} finally {
lock.unlock();
}
return value;
}
public static IIcon getBlockIcon(IIcon icon, Block block, int face) {
@@ -197,56 +237,55 @@ public class CTMUtils {
return RenderPassAPI.instance.skipDefaultRendering(block);
}
private static void registerOverride(TileOverride override) {
lock.lock();
try {
if (override != null && !override.isDisabled()) {
boolean registered = false;
List<BlockStateMatcher> matchingBlocks = override.getMatchingBlocks();
if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) {
for (BlockStateMatcher matcher : matchingBlocks) {
if (matcher == null) {
continue;
}
Block block = matcher.getBlock();
List<BlockStateMatcher> list = blockOverrides.computeIfAbsent(block, k -> new ArrayList<>());
list.add(matcher);
logger.fine("using %s for block %s", override, BlockAPI.getBlockName(block));
registered = true;
private static void registerOverrideWithoutLock(Overrides overrides, TileOverride override) {
if (override != null && !override.isDisabled()) {
boolean registered = false;
List<BlockStateMatcher> matchingBlocks = override.getMatchingBlocks();
if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) {
for (BlockStateMatcher matcher : matchingBlocks) {
if (matcher == null) {
continue;
}
}
Set<String> matchingTiles = override.getMatchingTiles();
if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) {
for (String name : matchingTiles) {
List<TileOverride> list = tileOverrides.computeIfAbsent(name, k -> new ArrayList<>());
list.add(override);
logger.fine("using %s for tile %s", override, name);
registered = true;
}
}
if (registered) {
allOverrides.add(override);
Block block = matcher.getBlock();
List<BlockStateMatcher> list = overrides.block.computeIfAbsent(block, k -> new ArrayList<>());
list.add(matcher);
logger.fine("using %s for block %s", override, BlockAPI.getBlockName(block));
registered = true;
}
}
} finally {
lock.unlock();
Set<String> matchingTiles = override.getMatchingTiles();
if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) {
for (String name : matchingTiles) {
List<TileOverride> list = overrides.tile.computeIfAbsent(name, k -> new ArrayList<>());
list.add(override);
logger.fine("using %s for tile %s", override, name);
registered = true;
}
}
if (registered) {
overrides.all.add(override);
}
}
}
private static void setBlankResourceWithoutLock() {
RenderBlocksUtils.blankIcon = tileLoader.getIcon(RenderPassAPI.instance.getBlankResource());
}
public static void setBlankResource() {
lock.lock();
long stamp = lock.writeLock();
try {
RenderBlocksUtils.blankIcon = tileLoader.getIcon(RenderPassAPI.instance.getBlankResource());
setBlankResourceWithoutLock();
} finally {
lock.unlock();
lock.unlockWrite(stamp);
}
}
private static TileOverrideIterator.IJK newIJKIterator() {
return new TileOverrideIterator.IJK(blockOverrides, tileOverrides);
return new TileOverrideIterator.IJK(overrides.block, overrides.tile);
}
private static TileOverrideIterator.Metadata newMetadataIterator() {
return new TileOverrideIterator.Metadata(blockOverrides, tileOverrides);
return new TileOverrideIterator.Metadata(overrides.block, overrides.tile);
}
}