package net.coderbot.iris.shaderpack; import com.gtnewhorizons.angelica.config.AngelicaConfig; import it.unimi.dsi.fastutil.ints.Int2ObjectMap; import it.unimi.dsi.fastutil.ints.Int2ObjectMaps; import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap; import it.unimi.dsi.fastutil.objects.Object2IntFunction; import it.unimi.dsi.fastutil.objects.Object2IntMap; import it.unimi.dsi.fastutil.objects.Object2IntMaps; import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap; import lombok.Getter; import net.coderbot.iris.Iris; import net.coderbot.iris.shaderpack.materialmap.BlockEntry; import net.coderbot.iris.shaderpack.materialmap.EntityFlatteningMap; import net.coderbot.iris.shaderpack.materialmap.BlockRenderType; import net.coderbot.iris.shaderpack.materialmap.NamespacedId; import net.coderbot.iris.shaderpack.materialmap.PropertiesTokenizer; import net.coderbot.iris.shaderpack.option.ShaderPackOptions; import net.coderbot.iris.shaderpack.preprocessor.PropertiesPreprocessor; import net.minecraft.item.Item; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; import net.minecraftforge.oredict.OreDictionary; import java.io.IOException; import java.io.StringReader; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.NoSuchFileException; import java.nio.file.Path; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.Properties; import java.util.regex.Pattern; /** * A utility class for parsing entries in item.properties, block.properties, and entities.properties files in shaderpacks */ public class IdMap { /** * Maps a given item ID to an integer ID */ private final Object2IntMap itemIdMap; @Getter private final Int2ObjectMap> itemNbtEntries; /** * Maps a given entity ID to an integer ID */ private final Object2IntMap entityIdMap; @Getter private final Int2ObjectMap> entityNbtEntries; /** * Maps block states to block ids defined in block.properties */ private Int2ObjectMap> blockPropertiesMap; /** * A set of render type overrides for specific blocks. Allows shader packs to move blocks to different render types. */ @Getter private Map blockRenderTypeMap; /** True when block.properties contained a preprocessor directive guarding a 1.7.10-specific section. */ private final boolean hasLegacySection; public boolean hasLegacySection() { return hasLegacySection; } private static final Pattern LEGACY_DIRECTIVE_PATTERN = Pattern.compile( "(?m)^\\s*#\\s*(?:if|elif|ifdef|ifndef)\\b[^\\n]*\\bMC_VERSION\\b[^\\n]*\\b10710\\b"); /** * Detects whether a pack's block.properties has a dedicated 1.7.10 section. */ public static boolean detectLegacySection(Path shaderPath) { String rawBlockProperties = readProperties(shaderPath, "block.properties"); return rawBlockProperties != null && LEGACY_DIRECTIVE_PATTERN.matcher(rawBlockProperties).find(); } public static String modernFallbackMcVersion() { return AngelicaConfig.modernFallbackMcVersion > 0 ? String.valueOf(AngelicaConfig.modernFallbackMcVersion) : "260101"; } IdMap(Path shaderPath, ShaderPackOptions shaderPackOptions, Iterable environmentDefines) { // Check if block.properties has a dedicated 1.7.10 section this.hasLegacySection = detectLegacySection(shaderPath); Iterable resolvedDefines; if (this.hasLegacySection) { // Pack has a 1.7.10 section resolvedDefines = environmentDefines; loadProperties(shaderPath, "block.properties", shaderPackOptions, environmentDefines).ifPresent(blockProperties -> { blockPropertiesMap = parseBlockMap(blockProperties, "block.", "block.properties"); blockRenderTypeMap = parseRenderTypeMap(blockProperties, "layer.", "block.properties"); }); } else { // No 1.7.10 section, use modern MC_VERSION and convert entries ArrayList modernDefines = new ArrayList<>(); for (StringPair define : environmentDefines) { if (!"MC_VERSION".equals(define.getKey())) { modernDefines.add(define); } } modernDefines.add(new StringPair("MC_VERSION", modernFallbackMcVersion())); resolvedDefines = modernDefines; loadProperties(shaderPath, "block.properties", shaderPackOptions, modernDefines).ifPresent(blockProperties -> { blockPropertiesMap = parseBlockMap(blockProperties, "block.", "block.properties"); blockRenderTypeMap = parseRenderTypeMap(blockProperties, "layer.", "block.properties"); }); } final ParsedIdMap parsedItems = loadProperties(shaderPath, "item.properties", shaderPackOptions, resolvedDefines) .map(p -> parseIdMap(p, "item.", "item.properties")) .orElse(new ParsedIdMap(Object2IntMaps.emptyMap(), new Int2ObjectOpenHashMap<>())); itemIdMap = parsedItems.simpleMap(); itemNbtEntries = parsedItems.nbtEntries(); final ParsedIdMap parsedEntities = loadProperties(shaderPath, "entity.properties", shaderPackOptions, resolvedDefines) .map(p -> parseIdMap(p, "entity.", "entity.properties")) .orElse(new ParsedIdMap(Object2IntMaps.emptyMap(), new Int2ObjectOpenHashMap<>())); entityIdMap = augmentEntityIdMap(parsedEntities.simpleMap(), parsedEntities.nbtEntries()); entityNbtEntries = parsedEntities.nbtEntries(); // TODO: Properly override block render layers if (blockPropertiesMap == null) { // Fill in with default values... blockPropertiesMap = new Int2ObjectOpenHashMap<>(); LegacyIdMap.addLegacyValues(blockPropertiesMap); } if (blockRenderTypeMap == null) { blockRenderTypeMap = Collections.emptyMap(); } } /** * Loads properties from a properties file in a shaderpack path */ private static Optional loadProperties(Path shaderPath, String name, ShaderPackOptions shaderPackOptions, Iterable environmentDefines) { String fileContents = readProperties(shaderPath, name); if (fileContents == null) { return Optional.empty(); } String processed = PropertiesPreprocessor.preprocessSource(fileContents, shaderPackOptions, environmentDefines); StringReader propertiesReader = new StringReader(processed); // Note: ordering of properties is significant // See https://github.com/IrisShaders/Iris/issues/1327 and the relevant putIfAbsent calls in // BlockMaterialMapping Properties properties = new OrderBackedProperties(); try { properties.load(propertiesReader); } catch (IOException e) { Iris.logger.error("Error loading " + name + " at " + shaderPath, e); return Optional.empty(); } return Optional.of(properties); } private static String readProperties(Path shaderPath, String name) { try { // ID maps should be encoded in ISO_8859_1. return Files.readString(shaderPath.resolve(name), StandardCharsets.ISO_8859_1); } catch (NoSuchFileException e) { Iris.logger.debug("An " + name + " file was not found in the current shaderpack"); return null; } catch (IOException e) { Iris.logger.error("An IOException occurred reading " + name + " from the current shaderpack", e); return null; } } /** * For modern shaderpacks: also expose entries under their 1.7.10 entity names * so runtime lookups match EntityList's registered names directly. * * Modern names whose 1.7.10 counterpart is NBT-discriminated (e.g. wither_skeleton * is just Skeleton with SkeletonType=1) are routed into the NBT-conditional map * instead of being aliased into the simple map — otherwise the simple lookup for * "Skeleton" would short-circuit and match every skeleton variant. */ private static Object2IntMap augmentEntityIdMap( Object2IntMap idMap, Int2ObjectMap> nbtEntries) { Object2IntMap augmented = new Object2IntOpenHashMap<>(idMap); augmented.defaultReturnValue(-1); for (Object2IntMap.Entry entry : idMap.object2IntEntrySet()) { NamespacedId id = entry.getKey(); if (!"minecraft".equals(id.getNamespace())) { continue; } final int intId = entry.getIntValue(); BlockEntry nbtMapping = EntityFlatteningMap.toLegacyWithNbt(id.getName()); if (nbtMapping != null) { nbtEntries.computeIfAbsent(intId, k -> new ArrayList<>()).add(nbtMapping); continue; } String legacyName = EntityFlatteningMap.toLegacy(id.getName()); if (legacyName != null) { augmented.putIfAbsent(new NamespacedId(legacyName), intId); } } return Object2IntMaps.unmodifiable(augmented); } /** * Parses a space-delimited list of identifiers. * Identifiers with spaces or special characters can be enclosed in double quotes. * Use backslash to escape quotes or backslashes within quoted strings. * * Examples (input -> parsed result): * minecraft:stone natura:berry * -> minecraft:stone, natura:berry * * minecraft:stone "Natura:N Crops" * -> minecraft:stone, Natura:N Crops * * "SomeDumbMod:Foo\\ \"Bar\":3" * -> SomeDumbMod:Foo\ "Bar":3 * * @param value The space-delimited string to parse * @param fileName The name of the properties file (for error messages) * @param key The property key being parsed (for error messages) * @return List of parsed identifiers */ static List parseIdentifierList(String value, String fileName, String key) { return PropertiesTokenizer.tokenizeValues(value, ' '); } record ParsedIdMap(Object2IntMap simpleMap, Int2ObjectMap> nbtEntries) {} /** * Parses a NamespacedId map in OptiFine format */ private static ParsedIdMap parseIdMap(Properties properties, String keyPrefix, String fileName) { Object2IntMap idMap = new Object2IntOpenHashMap<>(); idMap.defaultReturnValue(-1); Int2ObjectMap> nbtEntries = new Int2ObjectOpenHashMap<>(); properties.forEach((keyObject, valueObject) -> { String key = (String) keyObject; String value = (String) valueObject; if (!key.startsWith(keyPrefix)) { // Not a valid line, ignore it return; } int intId; try { intId = Integer.parseInt(key.substring(keyPrefix.length())); } catch (NumberFormatException e) { // Not a valid property line Iris.logger.warn("Failed to parse line in " + fileName + ": invalid key " + key); return; } // Parse identifiers for (String part : parseIdentifierList(value, fileName, key)) { if (part.contains("[")) { // NBT-conditional entry try { BlockEntry entry = BlockEntry.parse(part); if (entry.hasNbtProperties()) { nbtEntries.computeIfAbsent(intId, k -> new ArrayList<>()).add(entry); } else { idMap.put(entry.id(), intId); } } catch (Exception e) { Iris.logger.warn("Failed to parse NBT entry in " + fileName + " for key " + key + ": " + part, e); } continue; } if (part.contains("=")) { // Avoid tons of logspam for now Iris.logger.warn("Failed to parse an ResourceLocation in " + fileName + " for the key " + key + ": state properties are currently not supported: " + part); continue; } // Note: NamespacedId performs no validation on the content. That will need to be done by whatever is // converting these things to ResourceLocations. idMap.put(new NamespacedId(part), intId); } }); return new ParsedIdMap(Object2IntMaps.unmodifiable(idMap), nbtEntries); } private static Int2ObjectMap> parseBlockMap(Properties properties, String keyPrefix, String fileName) { Int2ObjectMap> entriesById = new Int2ObjectOpenHashMap<>(); properties.forEach((keyObject, valueObject) -> { final String key = (String) keyObject; StringBuilder value = new StringBuilder((String) valueObject); if (!key.startsWith(keyPrefix)) { // Not a valid line, ignore it return; } final int intId; try { intId = Integer.parseInt(key.substring(keyPrefix.length())); } catch (NumberFormatException e) { // Not a valid property line Iris.logger.warn("Failed to parse line in " + fileName + ": invalid key " + key); return; } final List entries = new ArrayList<>(); if (value.toString().contains("minecraft:leaves")) { ArrayList leaves = OreDictionary.getOres("treeLeaves"); for (ItemStack leaf : leaves) { if (leaf.getItem() instanceof ItemBlock) { Iris.logger.warn("Found leaf " + Item.itemRegistry.getNameForObject(leaf.getItem())); value.append(" ").append(Item.itemRegistry.getNameForObject(leaf.getItem())); } } } // Parse identifiers for (String part : parseIdentifierList(value.toString(), fileName, key)) { if (part.isEmpty()) { continue; } try { entries.add(BlockEntry.parse(part)); } catch (Exception e) { Iris.logger.warn("Unexpected error while parsing an entry from " + fileName + " for the key " + key + ":", e); } } entriesById.put(intId, Collections.unmodifiableList(entries)); }); return Int2ObjectMaps.unmodifiable(entriesById); } /** * Parses a render layer map. * * This feature is used by Chocapic v9 and Wisdom Shaders. Otherwise, it is a rarely-used feature. */ private static Map parseRenderTypeMap(Properties properties, String keyPrefix, String fileName) { Map overrides = new HashMap<>(); properties.forEach((keyObject, valueObject) -> { String key = (String) keyObject; String value = (String) valueObject; if (!key.startsWith(keyPrefix)) { // Not a valid line, ignore it return; } // Note: We have to remove the prefix "layer." because fromString expects "cutout", not "layer.cutout". String keyWithoutPrefix = key.substring(keyPrefix.length()); BlockRenderType renderType = BlockRenderType.fromString(keyWithoutPrefix).orElse(null); if (renderType == null) { Iris.logger.warn("Failed to parse line in " + fileName + ": invalid block render type: " + key); return; } for (String part : parseIdentifierList(value, fileName, key)) { // Note: NamespacedId performs no validation on the content. That will need to be done by whatever is // converting these things to ResourceLocations. overrides.put(new NamespacedId(part), renderType); } }); return overrides; } public Int2ObjectMap> getBlockProperties() { return blockPropertiesMap; } public Object2IntFunction getItemIdMap() { return itemIdMap; } public Object2IntFunction getEntityIdMap() { return entityIdMap; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } IdMap idMap = (IdMap) o; return Objects.equals(itemIdMap, idMap.itemIdMap) && Objects.equals(entityIdMap, idMap.entityIdMap) && Objects.equals(blockPropertiesMap, idMap.blockPropertiesMap) && Objects.equals(blockRenderTypeMap, idMap.blockRenderTypeMap); } @Override public int hashCode() { return Objects.hash(itemIdMap, entityIdMap, blockPropertiesMap, blockRenderTypeMap); } }