mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-21 21:02:15 +00:00
306 lines
9.9 KiB
Java
306 lines
9.9 KiB
Java
package net.coderbot.iris.shaderpack;
|
|
|
|
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 net.coderbot.iris.Iris;
|
|
import net.coderbot.iris.shaderpack.materialmap.BlockEntry;
|
|
import net.coderbot.iris.shaderpack.materialmap.BlockRenderType;
|
|
import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
|
|
import net.coderbot.iris.shaderpack.option.ShaderPackOptions;
|
|
import net.coderbot.iris.shaderpack.preprocessor.PropertiesPreprocessor;
|
|
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;
|
|
|
|
/**
|
|
* 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<NamespacedId> itemIdMap;
|
|
|
|
/**
|
|
* Maps a given entity ID to an integer ID
|
|
*/
|
|
private final Object2IntMap<NamespacedId> entityIdMap;
|
|
|
|
/**
|
|
* Maps block states to block ids defined in block.properties
|
|
*/
|
|
private Int2ObjectMap<List<BlockEntry>> blockPropertiesMap;
|
|
|
|
/**
|
|
* A set of render type overrides for specific blocks. Allows shader packs to move blocks to different render types.
|
|
*/
|
|
private Map<NamespacedId, BlockRenderType> blockRenderTypeMap;
|
|
|
|
IdMap(Path shaderPath, ShaderPackOptions shaderPackOptions, Iterable<StringPair> environmentDefines) {
|
|
itemIdMap = loadProperties(shaderPath, "item.properties", shaderPackOptions, environmentDefines).map(IdMap::parseItemIdMap).orElse(Object2IntMaps.emptyMap());
|
|
|
|
entityIdMap = loadProperties(shaderPath, "entity.properties", shaderPackOptions, environmentDefines).map(IdMap::parseEntityIdMap).orElse(Object2IntMaps.emptyMap());
|
|
|
|
loadProperties(shaderPath, "block.properties", shaderPackOptions, environmentDefines).ifPresent(blockProperties -> {
|
|
blockPropertiesMap = parseBlockMap(blockProperties, "block.", "block.properties");
|
|
blockRenderTypeMap = parseRenderTypeMap(blockProperties, "layer.", "block.properties");
|
|
});
|
|
|
|
// 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<Properties> loadProperties(Path shaderPath, String name, ShaderPackOptions shaderPackOptions,
|
|
Iterable<StringPair> 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 new String(Files.readAllBytes(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;
|
|
}
|
|
}
|
|
|
|
private static Object2IntMap<NamespacedId> parseItemIdMap(Properties properties) {
|
|
return parseIdMap(properties, "item.", "item.properties");
|
|
}
|
|
|
|
private static Object2IntMap<NamespacedId> parseEntityIdMap(Properties properties) {
|
|
return parseIdMap(properties, "entity.", "entity.properties");
|
|
}
|
|
|
|
/**
|
|
* Parses a NamespacedId map in OptiFine format
|
|
*/
|
|
private static Object2IntMap<NamespacedId> parseIdMap(Properties properties, String keyPrefix, String fileName) {
|
|
Object2IntMap<NamespacedId> idMap = new Object2IntOpenHashMap<>();
|
|
idMap.defaultReturnValue(-1);
|
|
|
|
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;
|
|
}
|
|
|
|
// Split on any whitespace
|
|
for (String part : value.split("\\s+")) {
|
|
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 Object2IntMaps.unmodifiable(idMap);
|
|
}
|
|
|
|
private static Int2ObjectMap<List<BlockEntry>> parseBlockMap(Properties properties, String keyPrefix, String fileName) {
|
|
Int2ObjectMap<List<BlockEntry>> 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<BlockEntry> entries = new ArrayList<>();
|
|
|
|
if (value.toString().contains("minecraft:leaves")) {
|
|
ArrayList<ItemStack> leaves = OreDictionary.getOres("treeLeaves");
|
|
for (ItemStack leaf : leaves) {
|
|
if (leaf.getItem() instanceof ItemBlock) {
|
|
Iris.logger.warn("Found leaf " + leaf.getItem().itemRegistry.getNameForObject(leaf.getItem()));
|
|
value.append(" ").append(leaf.getItem().itemRegistry.getNameForObject(leaf.getItem()));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Split on whitespace groups, not just single spaces
|
|
for (String part : value.toString().split("\\s+")) {
|
|
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<NamespacedId, BlockRenderType> parseRenderTypeMap(Properties properties, String keyPrefix, String fileName) {
|
|
Map<NamespacedId, BlockRenderType> 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 : value.split("\\s+")) {
|
|
// 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<List<BlockEntry>> getBlockProperties() {
|
|
return blockPropertiesMap;
|
|
}
|
|
|
|
public Object2IntFunction<NamespacedId> getItemIdMap() {
|
|
return itemIdMap;
|
|
}
|
|
|
|
public Object2IntFunction<NamespacedId> getEntityIdMap() {
|
|
return entityIdMap;
|
|
}
|
|
|
|
public Map<NamespacedId, BlockRenderType> getBlockRenderTypeMap() {
|
|
return blockRenderTypeMap;
|
|
}
|
|
|
|
@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);
|
|
}
|
|
}
|