diff --git a/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java b/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java index 9a76a8cb7..65fb602e8 100644 --- a/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java +++ b/src/main/java/com/prupe/mcpatcher/ctm/CTMUtils.java @@ -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 allOverrides = new ArrayList<>(); - private static final Map> blockOverrides = new IdentityHashMap<>(); - private static final Map> tileOverrides = new HashMap<>(); + private static class Overrides { + private final List all = new ArrayList<>(); + private final Map> block = new IdentityHashMap<>(); + private final Map> 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 = 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> entry : blockOverrides.entrySet()) { + for (Map.Entry> 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 overrides : blockOverrides.values()) { + for (List overrides : newOverrides.block.values()) { overrides.sort((m1, m2) -> { TileOverride o1 = (TileOverride) m1.getData(); TileOverride o2 = (TileOverride) m2.getData(); return o1.compareTo(o2); }); } - for (List overrides : tileOverrides.values()) { + for (List 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 matchingBlocks = override.getMatchingBlocks(); - if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) { - for (BlockStateMatcher matcher : matchingBlocks) { - if (matcher == null) { - continue; - } - Block block = matcher.getBlock(); - List 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 matchingBlocks = override.getMatchingBlocks(); + if (!MCPatcherUtils.isNullOrEmpty(matchingBlocks)) { + for (BlockStateMatcher matcher : matchingBlocks) { + if (matcher == null) { + continue; } - } - Set matchingTiles = override.getMatchingTiles(); - if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) { - for (String name : matchingTiles) { - List 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 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 matchingTiles = override.getMatchingTiles(); + if (!MCPatcherUtils.isNullOrEmpty(matchingTiles)) { + for (String name : matchingTiles) { + List 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); } }