mirror of
https://github.com/GTNewHorizons/Angelica.git
synced 2026-11-22 05:12:16 +00:00
Add NBT matching to list of valid block/item entries (#1771)
Co-authored-by: Jason Mitchell <[email protected]>
This commit is contained in:
1 parent
c9633fd745
commit
dd1d3aa518
15 files changed
+1132
-252
No files matched your search
@@ -23,26 +23,33 @@ import java.util.Set;
|
||||
|
||||
public class BlockMaterialMapping {
|
||||
|
||||
public record BlockIdMaps(Reference2ObjectMap<Block, Int2IntMap> blockMetaMap, NbtConditionalIdMap<Block> tileEntityMap) {}
|
||||
|
||||
/** Meta-key bit OR'd in at runtime when a snowy-tagged block has snow above it. */
|
||||
public static final int SNOWY_META_BIT = 0x10;
|
||||
|
||||
/**
|
||||
* Creates a two-level map structure for block material IDs.
|
||||
* Based on Iris's BlockState mapping approach adapted for 1.7.10's metadata system.
|
||||
* Creates the standard block meta ID map, the TileEntity NBT-conditional map, and registers
|
||||
* snowy blocks on {@link BlockRenderingSettings}.
|
||||
*/
|
||||
public static Reference2ObjectMap<Block, Int2IntMap> createBlockMetaIdMap(Int2ObjectMap<List<BlockEntry>> blockPropertiesMap, boolean skipFlattening) {
|
||||
public static BlockIdMaps createBlockIdMaps(Int2ObjectMap<List<BlockEntry>> blockPropertiesMap, boolean skipFlattening) {
|
||||
final Reference2ObjectMap<Block, Int2IntMap> blockMatches = new Reference2ObjectOpenHashMap<>();
|
||||
final NbtConditionalIdMap<Block> tileEntityMap = new NbtConditionalIdMap<>();
|
||||
final ReferenceSet<Block> snowyBlocks = new ReferenceOpenHashSet<>();
|
||||
|
||||
blockPropertiesMap.forEach((intId, entries) -> {
|
||||
for (BlockEntry entry : entries) {
|
||||
addBlockMetas(entry, blockMatches, intId, skipFlattening, snowyBlocks);
|
||||
if (entry.hasNbtProperties()) {
|
||||
addTileEntityEntry(entry, tileEntityMap, intId);
|
||||
} else {
|
||||
addBlockMetas(entry, blockMatches, tileEntityMap, intId, skipFlattening, snowyBlocks);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
BlockRenderingSettings.INSTANCE.setHasSnowyEntries(!snowyBlocks.isEmpty());
|
||||
BlockRenderingSettings.INSTANCE.setSnowyBlocks(snowyBlocks);
|
||||
return blockMatches;
|
||||
return new BlockIdMaps(blockMatches, tileEntityMap);
|
||||
}
|
||||
|
||||
public static Map<Block, BlockRenderLayer> createBlockTypeMap(Map<NamespacedId, BlockRenderType> blockPropertiesMap) {
|
||||
@@ -55,7 +62,8 @@ public class BlockMaterialMapping {
|
||||
if (block == null && "minecraft".equals(id.getNamespace())) {
|
||||
final List<BlockEntry> legacyEntries = FlatteningMap.toLegacy(id.getName(), Map.of());
|
||||
if (legacyEntries != null) {
|
||||
block = resolveBlockOrNull(legacyEntries.getFirst().getId());
|
||||
// Use the first entry for render type (render type applies per-block)
|
||||
block = resolveBlockOrNull(legacyEntries.getFirst().id());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -80,28 +88,64 @@ public class BlockMaterialMapping {
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an NBT-conditional ID map keyed by NamespacedId, for items or entities.
|
||||
*/
|
||||
public static NbtConditionalIdMap<NamespacedId> createNamespacedNbtMap(Int2ObjectMap<List<BlockEntry>> nbtEntries) {
|
||||
NbtConditionalIdMap<NamespacedId> map = new NbtConditionalIdMap<>();
|
||||
|
||||
nbtEntries.forEach((intId, entries) -> {
|
||||
for (BlockEntry entry : entries) {
|
||||
if (entry.hasNbtProperties()) {
|
||||
map.addCondition(entry.id(), entry.nbtProperties(), intId);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
return map;
|
||||
}
|
||||
|
||||
private static void addTileEntityEntry(BlockEntry entry, NbtConditionalIdMap<Block> teMap, int intId) {
|
||||
final NamespacedId id = entry.id();
|
||||
final ResourceLocation resourceLocation = new ResourceLocation(id.getNamespace(), id.getName());
|
||||
|
||||
final Block block = (Block) Block.blockRegistry.getObject(resourceLocation.toString());
|
||||
|
||||
if (block == null || block == Blocks.air) {
|
||||
return;
|
||||
}
|
||||
|
||||
teMap.addCondition(block, entry.nbtProperties(), intId);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds block+metadata combinations to the material ID map.
|
||||
* Based on Iris's addBlockStates method, adapted for 1.7.10 metadata system.
|
||||
*/
|
||||
private static void addBlockMetas(BlockEntry entry, Reference2ObjectMap<Block, Int2IntMap> idMap, int intId, boolean skipFlattening, ReferenceSet<Block> snowyBlocks) {
|
||||
final NamespacedId id = entry.getId();
|
||||
final Map<String, String> stateProps = entry.getStateProperties();
|
||||
private static void addBlockMetas(BlockEntry entry, Reference2ObjectMap<Block, Int2IntMap> idMap,
|
||||
NbtConditionalIdMap<Block> tileEntityMap, int intId,
|
||||
boolean skipFlattening, ReferenceSet<Block> snowyBlocks) {
|
||||
final NamespacedId id = entry.id();
|
||||
final Map<String, String> stateProps = entry.stateProperties();
|
||||
final String snowy = stateProps.get("snowy");
|
||||
final int snowyBit = "true".equals(snowy) ? SNOWY_META_BIT : 0;
|
||||
|
||||
// Vanilla modern names go through FlatteningMap; legacy-section packs and modded blocks
|
||||
// resolve directly from the registry.
|
||||
List<BlockEntry> targets = null;
|
||||
if (!skipFlattening && "minecraft".equals(id.getNamespace()) && (!stateProps.isEmpty() || entry.getMetas().isEmpty())) {
|
||||
if (!skipFlattening && "minecraft".equals(id.getNamespace()) && (!stateProps.isEmpty() || entry.metas().isEmpty())) {
|
||||
targets = FlatteningMap.toLegacy(id.getName(), stateProps);
|
||||
}
|
||||
if (targets == null) targets = List.of(entry);
|
||||
|
||||
for (BlockEntry target : targets) {
|
||||
final Block block = resolveBlockOrNull(target.getId());
|
||||
if (target.hasNbtProperties()) {
|
||||
addTileEntityEntry(target, tileEntityMap, intId);
|
||||
continue;
|
||||
}
|
||||
final Block block = resolveBlockOrNull(target.id());
|
||||
if (block == null) continue;
|
||||
applyMetas(block, target.getMetas(), idMap, intId, snowyBit);
|
||||
applyMetas(block, target.metas(), idMap, intId, snowyBit);
|
||||
if (snowy != null) snowyBlocks.add(block);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,6 +2,7 @@ package net.coderbot.iris.block_rendering;
|
||||
|
||||
import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
|
||||
import it.unimi.dsi.fastutil.ints.Int2IntMap;
|
||||
import it.unimi.dsi.fastutil.longs.Long2LongLinkedOpenHashMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntFunction;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.objects.ReferenceSet;
|
||||
@@ -18,16 +19,76 @@ import java.util.Map;
|
||||
public class BlockRenderingSettings {
|
||||
public static final BlockRenderingSettings INSTANCE = new BlockRenderingSettings();
|
||||
|
||||
public static final int CACHE_MISS = Integer.MIN_VALUE;
|
||||
|
||||
private static final int NBT_CACHE_INTERVAL_TICKS = 20;
|
||||
private static final int TE_NBT_CACHE_MAX = 8192;
|
||||
|
||||
private static final Long2LongLinkedOpenHashMap teNbtIdCache = new Long2LongLinkedOpenHashMap(256);
|
||||
private static final Object teNbtIdCacheLock = new Object();
|
||||
|
||||
static {
|
||||
teNbtIdCache.defaultReturnValue(-1L);
|
||||
}
|
||||
|
||||
public static long packBlockPos(int x, int y, int z) {
|
||||
return ((long) x & 0x3FFFFFFL) << 38 | ((long) y & 0xFFFL) << 26 | ((long) z & 0x3FFFFFFL);
|
||||
}
|
||||
|
||||
public static void invalidateTeNbtCache(int x, int y, int z) {
|
||||
final long key = packBlockPos(x, y, z);
|
||||
synchronized (teNbtIdCacheLock) {
|
||||
teNbtIdCache.remove(key);
|
||||
}
|
||||
}
|
||||
|
||||
public static int getCachedTeNbtId(long packedPos, long currentTick) {
|
||||
final long entry;
|
||||
synchronized (teNbtIdCacheLock) {
|
||||
entry = teNbtIdCache.get(packedPos);
|
||||
}
|
||||
if (entry == -1L) {
|
||||
return CACHE_MISS;
|
||||
}
|
||||
final long entryTick = entry >>> 32;
|
||||
if (currentTick - entryTick >= NBT_CACHE_INTERVAL_TICKS) {
|
||||
return CACHE_MISS;
|
||||
}
|
||||
return (int) entry;
|
||||
}
|
||||
|
||||
public static void cacheTeNbtId(long packedPos, int shaderId, long currentTick) {
|
||||
// Mask tick into low 31 bits so packed value never collides with the -1L sentinel.
|
||||
final long packed = ((currentTick & 0x7FFFFFFFL) << 32) | (shaderId & 0xFFFFFFFFL);
|
||||
synchronized (teNbtIdCacheLock) {
|
||||
teNbtIdCache.put(packedPos, packed);
|
||||
while (teNbtIdCache.size() > TE_NBT_CACHE_MAX) {
|
||||
teNbtIdCache.removeFirstLong();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void clearTeNbtCache() {
|
||||
synchronized (teNbtIdCacheLock) {
|
||||
teNbtIdCache.clear();
|
||||
}
|
||||
}
|
||||
|
||||
@Getter
|
||||
private boolean reloadRequired;
|
||||
private Reference2ObjectMap<Block, Int2IntMap> blockMetaMatches;
|
||||
private NbtConditionalIdMap<Block> blockNbtMap;
|
||||
private Map<Block, BlockRenderLayer> blockTypeIds;
|
||||
// note: no reload needed, entities are rebuilt every frame.
|
||||
@Setter
|
||||
private Object2IntFunction<NamespacedId> entityIds;
|
||||
@Setter
|
||||
private NbtConditionalIdMap<NamespacedId> entityNbtMap;
|
||||
// note: no reload needed, items are rendered every frame.
|
||||
@Setter
|
||||
private Object2IntFunction<NamespacedId> itemIds;
|
||||
@Setter
|
||||
private NbtConditionalIdMap<NamespacedId> itemNbtMap;
|
||||
@Getter
|
||||
private float ambientOcclusionLevel;
|
||||
private boolean disableDirectionalShading;
|
||||
@@ -41,6 +102,7 @@ public class BlockRenderingSettings {
|
||||
public BlockRenderingSettings() {
|
||||
reloadRequired = false;
|
||||
blockMetaMatches = null;
|
||||
blockNbtMap = null;
|
||||
blockTypeIds = null;
|
||||
ambientOcclusionLevel = 1.0F;
|
||||
disableDirectionalShading = false;
|
||||
@@ -82,11 +144,32 @@ public class BlockRenderingSettings {
|
||||
return itemIds;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public NbtConditionalIdMap<Block> getBlockNbtMap() {
|
||||
return blockNbtMap;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public NbtConditionalIdMap<NamespacedId> getItemNbtMap() {
|
||||
return itemNbtMap;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public NbtConditionalIdMap<NamespacedId> getEntityNbtMap() {
|
||||
return entityNbtMap;
|
||||
}
|
||||
|
||||
public void setBlockMetaMatches(Reference2ObjectMap<Block, Int2IntMap> blockMetaIds) {
|
||||
this.reloadRequired = true;
|
||||
this.blockMetaMatches = blockMetaIds;
|
||||
}
|
||||
|
||||
public void setBlockNbtMap(NbtConditionalIdMap<Block> blockNbtMap) {
|
||||
this.reloadRequired = true;
|
||||
this.blockNbtMap = blockNbtMap;
|
||||
clearTeNbtCache();
|
||||
}
|
||||
|
||||
public boolean hasSnowyEntries() {
|
||||
return hasSnowyEntries;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,233 @@
|
||||
package net.coderbot.iris.block_rendering;
|
||||
|
||||
import net.coderbot.iris.Iris;
|
||||
import net.coderbot.iris.shaderpack.materialmap.PropertiesTokenizer;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.nbt.NBTBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagList;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Maps objects with specific NBT properties to shader IDs. Generic over the
|
||||
* key type so it works for blocks, items, and entities.
|
||||
*
|
||||
* Example:
|
||||
* block.37=flower_pot[Item=minecraft:red_flower,Data=0]
|
||||
* item.10=diamond_sword[display.Name='Pointy Stick']
|
||||
*/
|
||||
public class NbtConditionalIdMap<K> {
|
||||
|
||||
/**
|
||||
* A single property matcher within a condition.
|
||||
*/
|
||||
record PropertyMatcher(String key, String[] path, String expectedValue,
|
||||
long expectedLong, boolean isExpectedLong,
|
||||
double expectedDouble, boolean isExpectedDouble) {
|
||||
boolean isPathMatch() { return path != null; }
|
||||
boolean isExistenceOnly() { return expectedValue == null; }
|
||||
}
|
||||
|
||||
record NbtCondition(PropertyMatcher[] matchers, int shaderId) {}
|
||||
|
||||
private final Map<K, List<NbtCondition>> conditionsByKey;
|
||||
|
||||
public NbtConditionalIdMap() {
|
||||
this.conditionsByKey = new HashMap<>();
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers an NBT condition. Unquoted values are resolved via item/block
|
||||
* registries at registration time. Single-quoted values are kept as literals.
|
||||
* Dot notation paths are pre-split here so we prevent allocations.
|
||||
*/
|
||||
public void addCondition(K key, Map<String, PropertiesTokenizer.NbtValue> nbtProperties, int shaderId) {
|
||||
final PropertyMatcher[] matchers = new PropertyMatcher[nbtProperties.size()];
|
||||
int i = 0;
|
||||
|
||||
for (Map.Entry<String, PropertiesTokenizer.NbtValue> entry : nbtProperties.entrySet()) {
|
||||
final String nbtKey = entry.getKey();
|
||||
final PropertiesTokenizer.NbtValue nbtValue = entry.getValue();
|
||||
|
||||
final String resolvedValue;
|
||||
if (nbtValue == null) {
|
||||
resolvedValue = null;
|
||||
|
||||
} else if (nbtValue.literal()) {
|
||||
resolvedValue = nbtValue.value();
|
||||
|
||||
} else {
|
||||
resolvedValue = resolveValue(nbtValue.value());
|
||||
}
|
||||
|
||||
final String[] path = nbtKey.contains(".") ? nbtKey.split("\\.") : null;
|
||||
|
||||
long expectedLong = 0;
|
||||
boolean isExpectedLong = false;
|
||||
double expectedDouble = 0;
|
||||
boolean isExpectedDouble = false;
|
||||
if (resolvedValue != null) {
|
||||
try {
|
||||
expectedLong = Long.parseLong(resolvedValue);
|
||||
isExpectedLong = true;
|
||||
} catch (NumberFormatException ignored) {}
|
||||
try {
|
||||
expectedDouble = Double.parseDouble(resolvedValue);
|
||||
isExpectedDouble = true;
|
||||
} catch (NumberFormatException ignored) {}
|
||||
}
|
||||
|
||||
matchers[i++] = new PropertyMatcher(nbtKey, path, resolvedValue,
|
||||
expectedLong, isExpectedLong, expectedDouble, isExpectedDouble);
|
||||
}
|
||||
|
||||
conditionsByKey.computeIfAbsent(key, k -> new ArrayList<>())
|
||||
.add(new NbtCondition(matchers, shaderId));
|
||||
}
|
||||
|
||||
public boolean hasConditions(K key) {
|
||||
return conditionsByKey.containsKey(key);
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
return conditionsByKey.isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves the shader ID by matching the provided NBT data.
|
||||
*/
|
||||
public int resolve(K key, NBTTagCompound nbt) {
|
||||
final List<NbtCondition> conditions = conditionsByKey.get(key);
|
||||
if (conditions == null) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (NbtCondition condition : conditions) {
|
||||
if (matchesNbt(nbt, condition.matchers())) {
|
||||
return condition.shaderId;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
private static boolean matchesNbt(NBTTagCompound nbt, PropertyMatcher[] matchers) {
|
||||
for (PropertyMatcher matcher : matchers) {
|
||||
if (matcher.isPathMatch()) {
|
||||
if (!matchesPath(nbt, matcher.path(), 0, matcher)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
} else {
|
||||
if (!nbt.hasKey(matcher.key())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!matcher.isExistenceOnly()) {
|
||||
if (!matchesNbtValue(nbt.getTag(matcher.key()), matcher)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Search through dot-separated path in NBT data.
|
||||
*/
|
||||
private static boolean matchesPath(NBTBase tag, String[] path, int depth, PropertyMatcher matcher) {
|
||||
if (depth == path.length) {
|
||||
if (matcher.isExistenceOnly()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return matchesNbtValue(tag, matcher);
|
||||
}
|
||||
|
||||
final String segment = path[depth];
|
||||
|
||||
if (tag instanceof NBTTagCompound compound) {
|
||||
if (!compound.hasKey(segment)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return matchesPath(compound.getTag(segment), path, depth + 1, matcher);
|
||||
}
|
||||
|
||||
if (tag instanceof NBTTagList list) {
|
||||
for (int i = 0; i < list.tagCount(); i++) {
|
||||
if (matchesPath(list.getCompoundTagAt(i), path, depth, matcher)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares an NBT tag's value against an expected string using type-specific
|
||||
* accessors to avoid toString() allocations where possible.
|
||||
* Makes it so you don't need to specify the type either in the .properties files.
|
||||
*/
|
||||
private static boolean matchesNbtValue(NBTBase tag, PropertyMatcher matcher) {
|
||||
return switch (tag.getId()) {
|
||||
case 1 -> // TAG_Byte
|
||||
matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagByte) tag).func_150290_f() == matcher.expectedLong();
|
||||
case 2 -> // TAG_Short
|
||||
matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagShort) tag).func_150289_e() == matcher.expectedLong();
|
||||
case 3 -> // TAG_Int
|
||||
matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagInt) tag).func_150287_d() == matcher.expectedLong();
|
||||
case 4 -> // TAG_Long
|
||||
matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagLong) tag).func_150291_c() == matcher.expectedLong();
|
||||
case 5 -> // TAG_Float
|
||||
matcher.isExpectedDouble() && ((net.minecraft.nbt.NBTTagFloat) tag).func_150288_h() == (float) matcher.expectedDouble();
|
||||
case 6 -> // TAG_Double
|
||||
matcher.isExpectedDouble() && ((net.minecraft.nbt.NBTTagDouble) tag).func_150286_g() == matcher.expectedDouble();
|
||||
case 8 -> // TAG_String
|
||||
matcher.expectedValue().equals(((net.minecraft.nbt.NBTTagString) tag).func_150285_a_());
|
||||
default -> // Compounds, lists, arrays — fall back to toString
|
||||
matcher.expectedValue().equals(PropertiesTokenizer.stripQuotes(tag.toString()));
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Tries to resolve a value as a registry name (item or block) to its numeric ID.
|
||||
* If the value is already numeric or can't be resolved, return it unchanged.
|
||||
*/
|
||||
private static String resolveValue(String value) {
|
||||
try {
|
||||
Integer.parseInt(value);
|
||||
return value;
|
||||
} catch (NumberFormatException ignored) {}
|
||||
|
||||
if (!value.contains(":")) {
|
||||
Iris.logger.warn("NBT value '{}' is missing a namespace, please use the full form e.g. 'minecraft:{}'", value, value);
|
||||
return value;
|
||||
}
|
||||
|
||||
final ResourceLocation loc = new ResourceLocation(value);
|
||||
|
||||
final Item item = (Item) Item.itemRegistry.getObject(loc.toString());
|
||||
if (item != null) {
|
||||
return String.valueOf(Item.getIdFromItem(item));
|
||||
}
|
||||
|
||||
final Block block = (Block) Block.blockRegistry.getObject(loc.toString());
|
||||
if (block != null) {
|
||||
return String.valueOf(Block.getIdFromBlock(block));
|
||||
}
|
||||
|
||||
Iris.logger.warn("Could not resolve '{}' to an item or block ID", value);
|
||||
return value;
|
||||
}
|
||||
}
|
||||
@@ -277,15 +277,19 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
|
||||
holder -> CommonUniforms.addNonDynamicUniforms(holder, programs.getPack().getIdMap(), programs.getPackDirectives(), this.updateNotifier)
|
||||
);
|
||||
|
||||
BlockRenderingSettings.INSTANCE.setBlockMetaMatches(BlockMaterialMapping.createBlockMetaIdMap(
|
||||
final var blockIdMaps = BlockMaterialMapping.createBlockIdMaps(
|
||||
programs.getPack().getIdMap().getBlockProperties(),
|
||||
programs.getPack().getIdMap().hasLegacySection()));
|
||||
programs.getPack().getIdMap().hasLegacySection());
|
||||
BlockRenderingSettings.INSTANCE.setBlockMetaMatches(blockIdMaps.blockMetaMap());
|
||||
BlockRenderingSettings.INSTANCE.setBlockNbtMap(blockIdMaps.tileEntityMap());
|
||||
BlockRenderingSettings.INSTANCE.setBlockTypeIds(BlockMaterialMapping.createBlockTypeMap(programs.getPack().getIdMap().getBlockRenderTypeMap()));
|
||||
|
||||
BlockRenderingSettings.INSTANCE.setEntityIds(programs.getPack().getIdMap().getEntityIdMap());
|
||||
BlockRenderingSettings.INSTANCE.setEntityNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getEntityNbtEntries()));
|
||||
|
||||
ItemMaterialHelper.clearCache();
|
||||
BlockRenderingSettings.INSTANCE.setItemIds(programs.getPack().getIdMap().getItemIdMap());
|
||||
BlockRenderingSettings.INSTANCE.setItemNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getItemNbtEntries()));
|
||||
BlockRenderingSettings.INSTANCE.setAmbientOcclusionLevel(programs.getPackDirectives().getAmbientOcclusionLevel());
|
||||
BlockRenderingSettings.INSTANCE.setDisableDirectionalShading(shouldDisableDirectionalShading());
|
||||
BlockRenderingSettings.INSTANCE.setUseSeparateAo(programs.getPackDirectives().shouldUseSeparateAo());
|
||||
|
||||
@@ -14,6 +14,7 @@ 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;
|
||||
@@ -45,11 +46,15 @@ public class IdMap {
|
||||
* Maps a given item ID to an integer ID
|
||||
*/
|
||||
private final Object2IntMap<NamespacedId> itemIdMap;
|
||||
@Getter
|
||||
private final Int2ObjectMap<List<BlockEntry>> itemNbtEntries;
|
||||
|
||||
/**
|
||||
* Maps a given entity ID to an integer ID
|
||||
*/
|
||||
private final Object2IntMap<NamespacedId> entityIdMap;
|
||||
@Getter
|
||||
private final Int2ObjectMap<List<BlockEntry>> entityNbtEntries;
|
||||
|
||||
/**
|
||||
* Maps block states to block ids defined in block.properties
|
||||
@@ -106,8 +111,17 @@ public class IdMap {
|
||||
});
|
||||
}
|
||||
|
||||
itemIdMap = loadProperties(shaderPath, "item.properties", shaderPackOptions, resolvedDefines).map(IdMap::parseItemIdMap).orElse(Object2IntMaps.emptyMap());
|
||||
entityIdMap = loadProperties(shaderPath, "entity.properties", shaderPackOptions, resolvedDefines).map(IdMap::parseEntityIdMap).orElse(Object2IntMaps.emptyMap());
|
||||
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
|
||||
|
||||
@@ -166,25 +180,37 @@ public class IdMap {
|
||||
}
|
||||
}
|
||||
|
||||
private static Object2IntMap<NamespacedId> parseItemIdMap(Properties properties) {
|
||||
return parseIdMap(properties, "item.", "item.properties");
|
||||
}
|
||||
|
||||
private static Object2IntMap<NamespacedId> parseEntityIdMap(Properties properties) {
|
||||
Object2IntMap<NamespacedId> idMap = parseIdMap(properties, "entity.", "entity.properties");
|
||||
|
||||
// For modern shader packs: translate modern entity names to 1.7.10 names
|
||||
// so runtime lookups match EntityList's registered names directly.
|
||||
/**
|
||||
* 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<NamespacedId> augmentEntityIdMap(
|
||||
Object2IntMap<NamespacedId> idMap,
|
||||
Int2ObjectMap<List<BlockEntry>> nbtEntries) {
|
||||
Object2IntMap<NamespacedId> augmented = new Object2IntOpenHashMap<>(idMap);
|
||||
augmented.defaultReturnValue(-1);
|
||||
|
||||
for (Object2IntMap.Entry<NamespacedId> entry : idMap.object2IntEntrySet()) {
|
||||
NamespacedId id = entry.getKey();
|
||||
if ("minecraft".equals(id.getNamespace())) {
|
||||
String legacyName = EntityFlatteningMap.toLegacy(id.getName());
|
||||
if (legacyName != null) {
|
||||
augmented.putIfAbsent(new NamespacedId(legacyName), entry.getIntValue());
|
||||
}
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -212,67 +238,18 @@ public class IdMap {
|
||||
* @return List of parsed identifiers
|
||||
*/
|
||||
static List<String> parseIdentifierList(String value, String fileName, String key) {
|
||||
if (value.indexOf('"') == -1) {
|
||||
String[] parts = value.split("\\s+");
|
||||
List<String> result = new ArrayList<>(parts.length);
|
||||
for (String part : parts) {
|
||||
if (!part.isEmpty()) {
|
||||
result.add(part);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Found quote, start of a dumb block ID
|
||||
List<String> result = new ArrayList<>();
|
||||
StringBuilder current = new StringBuilder();
|
||||
boolean inQuotes = false;
|
||||
boolean escaped = false;
|
||||
|
||||
for (int i = 0; i < value.length(); i++) {
|
||||
char c = value.charAt(i);
|
||||
|
||||
if (escaped) {
|
||||
current.append(c);
|
||||
escaped = false;
|
||||
} else if (c == '\\') {
|
||||
escaped = true;
|
||||
} else if (c == '"') {
|
||||
inQuotes = !inQuotes;
|
||||
} else if (Character.isWhitespace(c) && !inQuotes) {
|
||||
if (!current.isEmpty()) {
|
||||
result.add(current.toString());
|
||||
current.setLength(0);
|
||||
}
|
||||
} else {
|
||||
current.append(c);
|
||||
}
|
||||
}
|
||||
|
||||
// Didn't close a quote, warn
|
||||
if (inQuotes) {
|
||||
Iris.logger.warn(fileName + " [" + key + "]: Unclosed quote");
|
||||
}
|
||||
|
||||
// Trailing backslash, warn
|
||||
if (escaped) {
|
||||
Iris.logger.warn(fileName + " [" + key + "]: Trailing backslash");
|
||||
}
|
||||
|
||||
// Add final token
|
||||
if (!current.isEmpty()) {
|
||||
result.add(current.toString());
|
||||
}
|
||||
|
||||
return result;
|
||||
return PropertiesTokenizer.tokenizeValues(value, ' ');
|
||||
}
|
||||
|
||||
record ParsedIdMap(Object2IntMap<NamespacedId> simpleMap, Int2ObjectMap<List<BlockEntry>> nbtEntries) {}
|
||||
|
||||
/**
|
||||
* Parses a NamespacedId map in OptiFine format
|
||||
*/
|
||||
private static Object2IntMap<NamespacedId> parseIdMap(Properties properties, String keyPrefix, String fileName) {
|
||||
private static ParsedIdMap parseIdMap(Properties properties, String keyPrefix, String fileName) {
|
||||
Object2IntMap<NamespacedId> idMap = new Object2IntOpenHashMap<>();
|
||||
idMap.defaultReturnValue(-1);
|
||||
Int2ObjectMap<List<BlockEntry>> nbtEntries = new Int2ObjectOpenHashMap<>();
|
||||
|
||||
properties.forEach((keyObject, valueObject) -> {
|
||||
String key = (String) keyObject;
|
||||
@@ -295,6 +272,20 @@ public class IdMap {
|
||||
|
||||
// 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);
|
||||
@@ -307,7 +298,7 @@ public class IdMap {
|
||||
}
|
||||
});
|
||||
|
||||
return Object2IntMaps.unmodifiable(idMap);
|
||||
return new ParsedIdMap(Object2IntMaps.unmodifiable(idMap), nbtEntries);
|
||||
}
|
||||
|
||||
private static Int2ObjectMap<List<BlockEntry>> parseBlockMap(Properties properties, String keyPrefix, String fileName) {
|
||||
@@ -408,7 +399,7 @@ public class IdMap {
|
||||
return itemIdMap;
|
||||
}
|
||||
|
||||
public Object2IntFunction<NamespacedId> getEntityIdMap() {
|
||||
public Object2IntFunction<NamespacedId> getEntityIdMap() {
|
||||
return entityIdMap;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,124 +1,45 @@
|
||||
package net.coderbot.iris.shaderpack.materialmap;
|
||||
|
||||
import lombok.Getter;
|
||||
import net.coderbot.iris.Iris;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.Set;
|
||||
|
||||
@Getter
|
||||
public class BlockEntry {
|
||||
private final NamespacedId id;
|
||||
private final Set<Integer> metas;
|
||||
private final Map<String, String> stateProperties;
|
||||
public record BlockEntry(
|
||||
NamespacedId id,
|
||||
Set<Integer> metas,
|
||||
Map<String, String> stateProperties,
|
||||
Map<String, PropertiesTokenizer.NbtValue> nbtProperties
|
||||
) {
|
||||
public BlockEntry(NamespacedId id, Set<Integer> metas) {
|
||||
this(id, metas, Collections.emptyMap(), Collections.emptyMap());
|
||||
}
|
||||
|
||||
public BlockEntry(NamespacedId id, Set<Integer> metas) {
|
||||
this(id, metas, Collections.emptyMap());
|
||||
}
|
||||
public BlockEntry(NamespacedId id, Set<Integer> metas, Map<String, String> stateProperties) {
|
||||
this(id, metas, stateProperties, Collections.emptyMap());
|
||||
}
|
||||
|
||||
public BlockEntry(NamespacedId id, Set<Integer> metas, Map<String, String> stateProperties) {
|
||||
this.id = id;
|
||||
this.metas = metas;
|
||||
this.stateProperties = stateProperties;
|
||||
}
|
||||
public boolean hasNbtProperties() {
|
||||
return !nbtProperties.isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a block ID entry.
|
||||
*
|
||||
* @param entry The string representation of the entry. Must not be empty.
|
||||
*/
|
||||
@NotNull
|
||||
public static BlockEntry parse(@NotNull String entry) {
|
||||
if (entry.isEmpty()) {
|
||||
throw new IllegalArgumentException("Called BlockEntry::parse with an empty string");
|
||||
}
|
||||
public boolean hasStateProperties() {
|
||||
return !stateProperties.isEmpty();
|
||||
}
|
||||
|
||||
// We can assume that this array is of at least array length because the input string is non-empty.
|
||||
final String[] splitStates = entry.split(":");
|
||||
|
||||
// Trivial case: no states, no namespace
|
||||
if (splitStates.length == 1) {
|
||||
return new BlockEntry(new NamespacedId("minecraft", entry), Collections.emptySet());
|
||||
}
|
||||
|
||||
// Examples of what we accept:
|
||||
// stone
|
||||
// stone:0
|
||||
// minecraft:stone:0
|
||||
// minecraft:stone:0,1,2
|
||||
// minecraft:furnace:lit=true (blockstate property)
|
||||
// minecraft:oak_log:axis=y (blockstate property)
|
||||
|
||||
// Less trivial case: no metas or state properties, just a namespace
|
||||
if (splitStates.length == 2 && !StringUtils.isNumeric(splitStates[1].substring(0, 1))
|
||||
&& !splitStates[1].contains("=")) {
|
||||
return new BlockEntry(new NamespacedId(splitStates[0], splitStates[1]), Collections.emptySet());
|
||||
}
|
||||
|
||||
// Complex case: metas and/or state properties
|
||||
final int statesStart;
|
||||
final NamespacedId id;
|
||||
|
||||
if (splitStates.length == 2) {
|
||||
// "stone:0" or "stone:lit=true"
|
||||
statesStart = 1;
|
||||
id = new NamespacedId("minecraft", splitStates[0]);
|
||||
} else if (StringUtils.isNumeric(splitStates[1].substring(0, 1)) || splitStates[1].contains("=")) {
|
||||
// "stone:0:something" or "stone:lit=true:something" — unlikely but handle it
|
||||
statesStart = 1;
|
||||
id = new NamespacedId("minecraft", splitStates[0]);
|
||||
} else {
|
||||
// "minecraft:stone:0" or "minecraft:furnace:lit=true"
|
||||
statesStart = 2;
|
||||
id = new NamespacedId(splitStates[0], splitStates[1]);
|
||||
}
|
||||
|
||||
final Set<Integer> metas = new HashSet<>();
|
||||
final Map<String, String> properties = new HashMap<>();
|
||||
|
||||
for (int index = statesStart; index < splitStates.length; index++) {
|
||||
String segment = splitStates[index];
|
||||
|
||||
if (segment.contains("=")) {
|
||||
// Blockstate property: key=value
|
||||
for (String prop : segment.split(",")) {
|
||||
int eq = prop.indexOf('=');
|
||||
if (eq > 0 && eq < prop.length() - 1) {
|
||||
properties.put(prop.substring(0, eq), prop.substring(eq + 1));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Metadata IDs: comma-separated integers
|
||||
for (String metaPart : segment.split(",")) {
|
||||
try {
|
||||
metas.add(Integer.parseInt(metaPart));
|
||||
} catch (NumberFormatException e) {
|
||||
Iris.logger.warn("Warning: the block ID map entry \"" + entry + "\" could not be fully parsed:");
|
||||
Iris.logger.warn("- Metadata ids must be a comma separated list of one or more integers, but " + segment + " is not of that form!");
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Parses a block ID entry. All tokenization is delegated to {@link PropertiesTokenizer}.
|
||||
*
|
||||
* @param entry The string representation of the entry. Must not be empty.
|
||||
*/
|
||||
@NotNull
|
||||
public static BlockEntry parse(@NotNull String entry) {
|
||||
if (entry.isEmpty()) {
|
||||
throw new IllegalArgumentException("Called BlockEntry::parse with an empty string");
|
||||
}
|
||||
|
||||
return new BlockEntry(id, metas, properties);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
final BlockEntry that = (BlockEntry) o;
|
||||
return Objects.equals(id, that.id) && Objects.equals(metas, that.metas) && Objects.equals(stateProperties, that.stateProperties);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hash(id, metas, stateProperties);
|
||||
}
|
||||
final PropertiesTokenizer.ParsedBlockIdentifier parsed = PropertiesTokenizer.parseBlockIdentifier(entry);
|
||||
return new BlockEntry(parsed.id(), parsed.metas(), parsed.stateProperties(), parsed.nbtProperties());
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package net.coderbot.iris.shaderpack.materialmap;
|
||||
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
@@ -10,14 +11,15 @@ import java.util.Map;
|
||||
* In 1.7.10, entities are registered with names like "CaveSpider".
|
||||
* Some entities were also renamed or split into multiple types.
|
||||
*
|
||||
* This map is used at lookup time: when a modern shader pack references an entity by its
|
||||
* modern name, we resolve it to the 1.7.10 name that EntityList uses.
|
||||
*/
|
||||
public class EntityFlatteningMap {
|
||||
|
||||
/** Maps modern entity name -> 1.7.10 entity name. */
|
||||
private static final Map<String, String> MODERN_TO_LEGACY = new HashMap<>();
|
||||
|
||||
/** Maps modern entity name -> legacy entity name + NBT. */
|
||||
private static final Map<String, BlockEntry> MODERN_TO_LEGACY_NBT = new HashMap<>();
|
||||
|
||||
static {
|
||||
// Simple case changes
|
||||
simple("Arrow", "arrow");
|
||||
@@ -35,7 +37,6 @@ public class EntityFlatteningMap {
|
||||
simple("Pig", "pig");
|
||||
simple("Sheep", "sheep");
|
||||
simple("Silverfish", "silverfish");
|
||||
simple("Skeleton", "skeleton");
|
||||
simple("Slime", "slime");
|
||||
simple("Snowball", "snowball");
|
||||
simple("Spider", "spider");
|
||||
@@ -49,7 +50,6 @@ public class EntityFlatteningMap {
|
||||
simple("CaveSpider", "cave_spider");
|
||||
simple("EnderCrystal", "end_crystal");
|
||||
simple("EnderDragon", "ender_dragon");
|
||||
simple("EntityHorse", "horse");
|
||||
simple("EyeOfEnderSignal", "eye_of_ender");
|
||||
simple("FallingSand", "falling_block");
|
||||
simple("Fireball", "fireball");
|
||||
@@ -79,6 +79,36 @@ public class EntityFlatteningMap {
|
||||
simple("MinecartHopper", "hopper_minecart");
|
||||
simple("MinecartSpawner", "spawner_minecart");
|
||||
simple("MinecartTNT", "tnt_minecart");
|
||||
|
||||
MODERN_TO_LEGACY_NBT.put("skeleton", new BlockEntry(
|
||||
new NamespacedId("Skeleton"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("SkeletonType", new PropertiesTokenizer.NbtValue("0", false))));
|
||||
MODERN_TO_LEGACY_NBT.put("wither_skeleton", new BlockEntry(
|
||||
new NamespacedId("Skeleton"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("SkeletonType", new PropertiesTokenizer.NbtValue("1", false))));
|
||||
|
||||
// 1.7.10 EntityHorse with Type byte: 0=horse, 1=donkey, 2=mule, 3=zombie_horse,
|
||||
// 4=skeleton_horse. 1.11+ split each into its own entity type.
|
||||
MODERN_TO_LEGACY_NBT.put("horse", new BlockEntry(
|
||||
new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("Type", new PropertiesTokenizer.NbtValue("0", false))));
|
||||
MODERN_TO_LEGACY_NBT.put("donkey", new BlockEntry(
|
||||
new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("Type", new PropertiesTokenizer.NbtValue("1", false))));
|
||||
MODERN_TO_LEGACY_NBT.put("mule", new BlockEntry(
|
||||
new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("Type", new PropertiesTokenizer.NbtValue("2", false))));
|
||||
MODERN_TO_LEGACY_NBT.put("zombie_horse", new BlockEntry(
|
||||
new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("Type", new PropertiesTokenizer.NbtValue("3", false))));
|
||||
MODERN_TO_LEGACY_NBT.put("skeleton_horse", new BlockEntry(
|
||||
new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("Type", new PropertiesTokenizer.NbtValue("4", false))));
|
||||
|
||||
// 1.7.10 Zombie with IsVillager.
|
||||
MODERN_TO_LEGACY_NBT.put("zombie_villager", new BlockEntry(
|
||||
new NamespacedId("Zombie"), Collections.emptySet(), Collections.emptyMap(),
|
||||
Map.of("IsVillager", new PropertiesTokenizer.NbtValue("1", false))));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -89,6 +119,10 @@ public class EntityFlatteningMap {
|
||||
return MODERN_TO_LEGACY.get(modernName);
|
||||
}
|
||||
|
||||
public static BlockEntry toLegacyWithNbt(String modernName) {
|
||||
return MODERN_TO_LEGACY_NBT.get(modernName);
|
||||
}
|
||||
|
||||
private static void simple(String legacy, String modern) {
|
||||
MODERN_TO_LEGACY.put(modern, legacy);
|
||||
}
|
||||
|
||||
@@ -158,18 +158,18 @@ public class FlatteningMap {
|
||||
rename("dark_oak_wall_sign", "wall_sign");
|
||||
|
||||
// === Skull / Head blocks (ID 144) ===
|
||||
// In 1.7.10, skull type is stored in tile entity, not metadata.
|
||||
// All modern skull blocks map to the same 1.7.10 block.
|
||||
rename("skeleton_skull", "skull");
|
||||
rename("skeleton_wall_skull", "skull");
|
||||
rename("wither_skeleton_skull", "skull");
|
||||
rename("wither_skeleton_wall_skull", "skull");
|
||||
rename("zombie_head", "skull");
|
||||
rename("zombie_wall_head", "skull");
|
||||
rename("player_head", "skull");
|
||||
rename("player_wall_head", "skull");
|
||||
rename("creeper_head", "skull");
|
||||
rename("creeper_wall_head", "skull");
|
||||
// 1.7.10 stores skull type in TileEntitySkull's SkullType byte (0=skeleton,
|
||||
// 1=wither, 2=zombie, 3=player, 4=creeper).
|
||||
MODERN_TO_LEGACY.put("skeleton_skull", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("skeleton_wall_skull", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("wither_skeleton_skull", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("1", false)))));
|
||||
MODERN_TO_LEGACY.put("wither_skeleton_wall_skull", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("1", false)))));
|
||||
MODERN_TO_LEGACY.put("zombie_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("2", false)))));
|
||||
MODERN_TO_LEGACY.put("zombie_wall_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("2", false)))));
|
||||
MODERN_TO_LEGACY.put("player_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("3", false)))));
|
||||
MODERN_TO_LEGACY.put("player_wall_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("3", false)))));
|
||||
MODERN_TO_LEGACY.put("creeper_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("4", false)))));
|
||||
MODERN_TO_LEGACY.put("creeper_wall_head", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("4", false)))));
|
||||
|
||||
// ==========================================
|
||||
// Metadata variants (block split by flattening)
|
||||
@@ -321,29 +321,29 @@ public class FlatteningMap {
|
||||
meta("mossy_cobblestone_wall", "cobblestone_wall", 1);
|
||||
|
||||
// === Flower pot (ID 140) ===
|
||||
// In 1.7.10, flower pot contents are in the tile entity.
|
||||
// In 1.13+, each potted plant is a separate block.
|
||||
rename("potted_oak_sapling", "flower_pot");
|
||||
rename("potted_spruce_sapling", "flower_pot");
|
||||
rename("potted_birch_sapling", "flower_pot");
|
||||
rename("potted_jungle_sapling", "flower_pot");
|
||||
rename("potted_acacia_sapling", "flower_pot");
|
||||
rename("potted_dark_oak_sapling", "flower_pot");
|
||||
rename("potted_fern", "flower_pot");
|
||||
rename("potted_dandelion", "flower_pot");
|
||||
rename("potted_poppy", "flower_pot");
|
||||
rename("potted_blue_orchid", "flower_pot");
|
||||
rename("potted_allium", "flower_pot");
|
||||
rename("potted_azure_bluet", "flower_pot");
|
||||
rename("potted_red_tulip", "flower_pot");
|
||||
rename("potted_orange_tulip", "flower_pot");
|
||||
rename("potted_white_tulip", "flower_pot");
|
||||
rename("potted_pink_tulip", "flower_pot");
|
||||
rename("potted_oxeye_daisy", "flower_pot");
|
||||
rename("potted_red_mushroom", "flower_pot");
|
||||
rename("potted_brown_mushroom", "flower_pot");
|
||||
rename("potted_dead_bush", "flower_pot");
|
||||
rename("potted_cactus", "flower_pot");
|
||||
// 1.7.10 stores potted contents in TileEntityFlowerPot's NBT. 1.13+ has a separate block
|
||||
// per potted plant.
|
||||
MODERN_TO_LEGACY.put("potted_oak_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_spruce_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("1", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_birch_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("2", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_jungle_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("3", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_acacia_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("4", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_dark_oak_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false), "Data", new PropertiesTokenizer.NbtValue("5", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_fern", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:tallgrass", false), "Data", new PropertiesTokenizer.NbtValue("2", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_dandelion", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:yellow_flower", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_poppy", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_blue_orchid", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("1", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_allium", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("2", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_azure_bluet", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("3", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_red_tulip", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("4", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_orange_tulip", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("5", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_white_tulip", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("6", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_pink_tulip", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("7", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_oxeye_daisy", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false), "Data", new PropertiesTokenizer.NbtValue("8", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_red_mushroom", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_mushroom", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_brown_mushroom", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:brown_mushroom", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_dead_bush", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:deadbush", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
MODERN_TO_LEGACY.put("potted_cactus", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:cactus", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
|
||||
|
||||
// === Anvil (ID 145) ===
|
||||
// Bits 0-1 = facing, bits 2-3 = damage level
|
||||
@@ -928,26 +928,26 @@ public class FlatteningMap {
|
||||
List<BlockEntry> result = new ArrayList<>(Math.min(a.size(), b.size()));
|
||||
for (BlockEntry entryA : a) {
|
||||
for (BlockEntry entryB : b) {
|
||||
if (!entryA.getId().equals(entryB.getId())) continue;
|
||||
if (!entryA.id().equals(entryB.id())) continue;
|
||||
|
||||
Set<Integer> metasA = entryA.getMetas();
|
||||
Set<Integer> metasB = entryB.getMetas();
|
||||
Set<Integer> metasA = entryA.metas();
|
||||
Set<Integer> metasB = entryB.metas();
|
||||
|
||||
if (metasA.isEmpty() && metasB.isEmpty()) {
|
||||
// Both wildcard -> wildcard
|
||||
result.add(new BlockEntry(entryA.getId(), Collections.emptySet()));
|
||||
result.add(new BlockEntry(entryA.id(), Collections.emptySet()));
|
||||
} else if (metasA.isEmpty()) {
|
||||
// A is wildcard -> use B's constraint
|
||||
result.add(new BlockEntry(entryA.getId(), metasB));
|
||||
result.add(new BlockEntry(entryA.id(), metasB));
|
||||
} else if (metasB.isEmpty()) {
|
||||
// B is wildcard -> use A's constraint
|
||||
result.add(new BlockEntry(entryA.getId(), metasA));
|
||||
result.add(new BlockEntry(entryA.id(), metasA));
|
||||
} else {
|
||||
// Both have specific metas -> intersect
|
||||
Set<Integer> intersection = new IntOpenHashSet(metasA);
|
||||
intersection.retainAll(metasB);
|
||||
if (!intersection.isEmpty()) {
|
||||
result.add(new BlockEntry(entryA.getId(), intersection));
|
||||
result.add(new BlockEntry(entryA.id(), intersection));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,388 @@
|
||||
package net.coderbot.iris.shaderpack.materialmap;
|
||||
|
||||
import net.coderbot.iris.Iris;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
// This got complicated fast
|
||||
|
||||
/**
|
||||
* This class handles all processing of individual block entries per material ID line.
|
||||
*/
|
||||
public final class PropertiesTokenizer {
|
||||
|
||||
private PropertiesTokenizer() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits a property value into individual block identifier tokens.
|
||||
*/
|
||||
public static List<String> tokenizeValues(String input, char delimiter) {
|
||||
if (input.indexOf('"') == -1 && input.indexOf('\\') == -1 && input.indexOf('[') == -1) {
|
||||
return tokenizeSimple(input, delimiter);
|
||||
}
|
||||
return tokenizeFull(input, delimiter);
|
||||
}
|
||||
|
||||
// Most blocks should take this path
|
||||
private static List<String> tokenizeSimple(String input, char delimiter) {
|
||||
final List<String> result = new ArrayList<>();
|
||||
final boolean isWhitespaceDelim = Character.isWhitespace(delimiter);
|
||||
|
||||
if (isWhitespaceDelim) {
|
||||
for (String part : input.split("\\s+")) {
|
||||
if (!part.isEmpty()) {
|
||||
result.add(part);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (String part : input.split(String.valueOf(delimiter))) {
|
||||
final String trimmed = part.trim();
|
||||
if (!trimmed.isEmpty()) {
|
||||
result.add(trimmed);
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Found special characters
|
||||
private static List<String> tokenizeFull(String input, char delimiter) {
|
||||
final boolean isWhitespaceDelim = Character.isWhitespace(delimiter);
|
||||
final List<String> result = new ArrayList<>();
|
||||
final StringBuilder current = new StringBuilder();
|
||||
boolean inQuotes = false;
|
||||
boolean escaped = false;
|
||||
int bracketDepth = 0;
|
||||
|
||||
for (int i = 0; i < input.length(); i++) {
|
||||
final char c = input.charAt(i);
|
||||
|
||||
if (escaped) {
|
||||
if (bracketDepth > 0) {
|
||||
// Preserve escapes inside brackets for parseBlockIdentifier
|
||||
current.append('\\');
|
||||
}
|
||||
current.append(c);
|
||||
escaped = false;
|
||||
|
||||
} else if (c == '\\') {
|
||||
escaped = true;
|
||||
|
||||
} else if (bracketDepth > 0) {
|
||||
current.append(c);
|
||||
|
||||
if (c == '[') {
|
||||
bracketDepth++;
|
||||
}
|
||||
|
||||
else if (c == ']') {
|
||||
bracketDepth--;
|
||||
}
|
||||
|
||||
} else if (c == '[' && !inQuotes) {
|
||||
current.append(c);
|
||||
bracketDepth = 1;
|
||||
|
||||
} else if (c == '"') {
|
||||
inQuotes = !inQuotes;
|
||||
|
||||
} else if (!inQuotes && (isWhitespaceDelim ? Character.isWhitespace(c) : c == delimiter)) {
|
||||
if (!current.isEmpty()) {
|
||||
result.add(current.toString());
|
||||
current.setLength(0);
|
||||
}
|
||||
|
||||
} else {
|
||||
current.append(c);
|
||||
}
|
||||
}
|
||||
|
||||
if (inQuotes) {
|
||||
Iris.logger.warn("Unclosed quote in properties token: {}", input);
|
||||
}
|
||||
|
||||
if (!current.isEmpty()) {
|
||||
result.add(current.toString());
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Begin reading the special case block
|
||||
public static ParsedBlockIdentifier parseBlockIdentifier(String entry) {
|
||||
final StringBuilder blockIdBuilder = new StringBuilder();
|
||||
final Map<String, NbtValue> nbt = new LinkedHashMap<>();
|
||||
|
||||
boolean escaped = false;
|
||||
boolean inDoubleQuotes = false;
|
||||
boolean inSingleQuotes = false;
|
||||
boolean inBracket = false;
|
||||
|
||||
// NBT pair
|
||||
StringBuilder nbtKey = new StringBuilder();
|
||||
StringBuilder nbtValue = new StringBuilder();
|
||||
boolean readingValue = false;
|
||||
boolean valueLiteral = false;
|
||||
|
||||
for (int i = 0; i < entry.length(); i++) {
|
||||
final char c = entry.charAt(i);
|
||||
|
||||
// Ignore special characters
|
||||
if (escaped) {
|
||||
appendCurrent(inBracket, readingValue, blockIdBuilder, nbtKey, nbtValue, c);
|
||||
escaped = false;
|
||||
continue;
|
||||
}
|
||||
if (c == '\\') {
|
||||
escaped = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
// Detect special characters
|
||||
if (inSingleQuotes) {
|
||||
if (c == '\'') {
|
||||
inSingleQuotes = false;
|
||||
|
||||
} else {
|
||||
nbtValue.append(c);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (inDoubleQuotes) {
|
||||
if (c == '"') {
|
||||
inDoubleQuotes = false;
|
||||
|
||||
} else {
|
||||
appendCurrent(inBracket, readingValue, blockIdBuilder, nbtKey, nbtValue, c);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
if (c == '"') {
|
||||
inDoubleQuotes = true;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!inBracket) {
|
||||
if (c == '[') {
|
||||
inBracket = true;
|
||||
nbtKey.setLength(0);
|
||||
nbtValue.setLength(0);
|
||||
readingValue = false;
|
||||
valueLiteral = false;
|
||||
|
||||
} else {
|
||||
blockIdBuilder.append(c);
|
||||
}
|
||||
|
||||
} else {
|
||||
if (c == ']') {
|
||||
flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
|
||||
inBracket = false;
|
||||
|
||||
} else if (c == '=' && !readingValue) {
|
||||
readingValue = true;
|
||||
valueLiteral = false;
|
||||
|
||||
} else if (c == '\'' && readingValue && nbtValue.isEmpty()) {
|
||||
inSingleQuotes = true;
|
||||
valueLiteral = true;
|
||||
|
||||
} else if (c == ',') {
|
||||
flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
|
||||
nbtKey.setLength(0);
|
||||
nbtValue.setLength(0);
|
||||
readingValue = false;
|
||||
valueLiteral = false;
|
||||
|
||||
} else {
|
||||
if (readingValue) {
|
||||
nbtValue.append(c);
|
||||
|
||||
} else {
|
||||
nbtKey.append(c);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (inDoubleQuotes) {
|
||||
Iris.logger.warn("Unclosed double quote in block entry: {}", entry);
|
||||
}
|
||||
if (inSingleQuotes) {
|
||||
Iris.logger.warn("Unclosed single quote in block entry: {}", entry);
|
||||
}
|
||||
if (escaped) {
|
||||
Iris.logger.warn("Trailing backslash in block entry: {}", entry);
|
||||
}
|
||||
if (inBracket) {
|
||||
Iris.logger.warn("Unclosed bracket in block entry: {}", entry);
|
||||
flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
|
||||
}
|
||||
|
||||
final String baseEntry = blockIdBuilder.toString().trim();
|
||||
final Map<String, NbtValue> nbtProperties = nbt.isEmpty() ? Collections.emptyMap() : nbt;
|
||||
|
||||
return splitBaseEntry(entry, baseEntry, nbtProperties);
|
||||
}
|
||||
|
||||
/**
|
||||
* Splits the bracket-stripped portion of a block identifier (e.g. {@code minecraft:furnace:lit=true})
|
||||
* into its components.
|
||||
*
|
||||
* Accepted forms:
|
||||
* stone (vanilla block)
|
||||
* stone:0 (vanilla block with meta)
|
||||
* minecraft:stone (block with namespaced id specified)
|
||||
* minecraft:stone:0 (single meta)
|
||||
* minecraft:stone:0,1,2 (multiple metas)
|
||||
* minecraft:furnace:lit=true (blockstate property)
|
||||
* minecraft:oak_log:axis=y,x:variant=oak (multiple blockstate properties)
|
||||
* flower_pot:1[Item=minecraft:red_flower,Data=0] (used together with NBT brackets)
|
||||
*/
|
||||
private static ParsedBlockIdentifier splitBaseEntry(String entry, String baseEntry, Map<String, NbtValue> nbtProperties) {
|
||||
final Set<Integer> metas = new HashSet<>();
|
||||
final Map<String, String> stateProperties = new LinkedHashMap<>();
|
||||
|
||||
if (baseEntry.isEmpty()) {
|
||||
return new ParsedBlockIdentifier(
|
||||
new NamespacedId("minecraft", baseEntry),
|
||||
Collections.emptySet(),
|
||||
Collections.emptyMap(),
|
||||
nbtProperties
|
||||
);
|
||||
}
|
||||
|
||||
final String[] splitStates = baseEntry.split(":");
|
||||
|
||||
// Vanilla block (minecraft namespaced)
|
||||
if (splitStates.length == 1) {
|
||||
return new ParsedBlockIdentifier(
|
||||
new NamespacedId("minecraft", baseEntry),
|
||||
Collections.emptySet(),
|
||||
Collections.emptyMap(),
|
||||
nbtProperties
|
||||
);
|
||||
}
|
||||
|
||||
// Two-segment with no metas/state properties: "minecraft:stone"
|
||||
if (splitStates.length == 2
|
||||
&& !StringUtils.isNumeric(splitStates[1].substring(0, 1))
|
||||
&& !splitStates[1].contains("=")) {
|
||||
return new ParsedBlockIdentifier(
|
||||
new NamespacedId(splitStates[0], splitStates[1]),
|
||||
Collections.emptySet(),
|
||||
Collections.emptyMap(),
|
||||
nbtProperties
|
||||
);
|
||||
}
|
||||
|
||||
// Metas and/or state properties
|
||||
final NamespacedId id;
|
||||
final int statesStart;
|
||||
|
||||
if (splitStates.length == 2) {
|
||||
// "stone:0" or "stone:lit=true"
|
||||
id = new NamespacedId("minecraft", splitStates[0]);
|
||||
statesStart = 1;
|
||||
|
||||
} else if (StringUtils.isNumeric(splitStates[1].substring(0, 1)) || splitStates[1].contains("=")) {
|
||||
// "stone:0:something" or "stone:lit=true:something", likely will need this for snowy blocks in the future.
|
||||
id = new NamespacedId("minecraft", splitStates[0]);
|
||||
statesStart = 1;
|
||||
|
||||
} else {
|
||||
// "minecraft:stone:0" or "minecraft:furnace:lit=true"
|
||||
id = new NamespacedId(splitStates[0], splitStates[1]);
|
||||
statesStart = 2;
|
||||
}
|
||||
|
||||
for (int index = statesStart; index < splitStates.length; index++) {
|
||||
final String segment = splitStates[index];
|
||||
|
||||
if (segment.contains("=")) {
|
||||
// Blockstate property segment: key=value[,key=value...]
|
||||
for (String prop : segment.split(",")) {
|
||||
final int eq = prop.indexOf('=');
|
||||
if (eq > 0 && eq < prop.length() - 1) {
|
||||
stateProperties.put(prop.substring(0, eq), prop.substring(eq + 1));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Metadata segment (stone:[1,2,3,4,5])
|
||||
for (String metaPart : segment.split(",")) {
|
||||
try {
|
||||
metas.add(Integer.parseInt(metaPart));
|
||||
} catch (NumberFormatException e) {
|
||||
Iris.logger.warn("Warning: the block ID map entry \"{}\" could not be fully parsed:", entry);
|
||||
Iris.logger.warn("- Metadata ids must be a comma separated list of one or more integers, but {} is not of that form!", segment);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return new ParsedBlockIdentifier(
|
||||
id,
|
||||
metas.isEmpty() ? Collections.emptySet() : metas,
|
||||
stateProperties.isEmpty() ? Collections.emptyMap() : stateProperties,
|
||||
nbtProperties
|
||||
);
|
||||
}
|
||||
|
||||
private static void appendCurrent(boolean inBracket, boolean readingValue,
|
||||
StringBuilder blockIdBuilder, StringBuilder nbtKey,
|
||||
StringBuilder nbtValue, char c) {
|
||||
if (!inBracket) {
|
||||
blockIdBuilder.append(c);
|
||||
|
||||
} else if (readingValue) {
|
||||
nbtValue.append(c);
|
||||
|
||||
} else {
|
||||
nbtKey.append(c);
|
||||
}
|
||||
}
|
||||
|
||||
private static void flushNbtPair(StringBuilder key, StringBuilder value,
|
||||
boolean readingValue, boolean valueLiteral,
|
||||
Map<String, NbtValue> nbt) {
|
||||
final String k = key.toString().trim();
|
||||
if (k.isEmpty()) return;
|
||||
|
||||
if (!readingValue) {
|
||||
// No = was found, existence is good enough
|
||||
nbt.put(k, null);
|
||||
return;
|
||||
}
|
||||
|
||||
nbt.put(k, new NbtValue(value.toString().trim(), valueLiteral));
|
||||
}
|
||||
|
||||
public static String stripQuotes(String value) {
|
||||
if (value.length() >= 2 && value.charAt(0) == '"' && value.charAt(value.length() - 1) == '"') {
|
||||
return value.substring(1, value.length() - 1);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
public record NbtValue(String value, boolean literal) {
|
||||
}
|
||||
|
||||
public record ParsedBlockIdentifier(
|
||||
NamespacedId id,
|
||||
Set<Integer> metas,
|
||||
Map<String, String> stateProperties,
|
||||
Map<String, NbtValue> nbtProperties
|
||||
) {
|
||||
}
|
||||
}
|
||||
@@ -1,10 +1,16 @@
|
||||
package net.coderbot.iris.uniforms;
|
||||
|
||||
import it.unimi.dsi.fastutil.ints.Int2LongLinkedOpenHashMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntFunction;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntMap;
|
||||
import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
|
||||
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
|
||||
import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
import java.util.IdentityHashMap;
|
||||
import java.util.Map;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.entity.EntityList;
|
||||
@@ -21,10 +27,16 @@ public final class EntityIdHelper {
|
||||
private static final NamespacedId LIGHTNING_BOLT_ID = new NamespacedId("minecraft", "lightning_bolt");
|
||||
|
||||
private static final Object2IntMap<Class<?>> entityIdCache = new Object2IntOpenHashMap<>();
|
||||
private static final Map<Class<?>, NamespacedId> entityNameCache = new IdentityHashMap<>();
|
||||
private static Object2IntFunction<NamespacedId> cachedEntityIdMap;
|
||||
|
||||
private static final Int2LongLinkedOpenHashMap entityNbtCache = new Int2LongLinkedOpenHashMap();
|
||||
private static final int NBT_CACHE_INTERVAL_TICKS = 20;
|
||||
private static final int ENTITY_NBT_CACHE_MAX = 256;
|
||||
|
||||
static {
|
||||
entityIdCache.defaultReturnValue(Integer.MIN_VALUE);
|
||||
entityNbtCache.defaultReturnValue(-1L);
|
||||
}
|
||||
|
||||
private EntityIdHelper() {
|
||||
@@ -42,17 +54,48 @@ public final class EntityIdHelper {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Invalidate cache if the map changed (shader reload)
|
||||
// Invalidate caches if the map changed (shader reload)
|
||||
if (entityIdMap != cachedEntityIdMap) {
|
||||
entityIdCache.clear();
|
||||
entityNameCache.clear();
|
||||
entityNbtCache.clear();
|
||||
cachedEntityIdMap = entityIdMap;
|
||||
}
|
||||
|
||||
// Check NBT-conditional match first
|
||||
final NbtConditionalIdMap<NamespacedId> entityNbtMap = BlockRenderingSettings.INSTANCE.getEntityNbtMap();
|
||||
if (entityNbtMap != null && !entityNbtMap.isEmpty() && entity.worldObj != null) {
|
||||
final NamespacedId namespacedId = getCachedEntityName(entity);
|
||||
if (namespacedId != null && entityNbtMap.hasConditions(namespacedId)) {
|
||||
final int entityRuntimeId = entity.getEntityId();
|
||||
final long currentTick = entity.worldObj.getTotalWorldTime();
|
||||
final long cached = entityNbtCache.get(entityRuntimeId);
|
||||
|
||||
final int nbtId;
|
||||
if (cached != -1L && (currentTick - (cached >>> 32)) < NBT_CACHE_INTERVAL_TICKS) {
|
||||
nbtId = (int) cached;
|
||||
} else {
|
||||
final NBTTagCompound nbt = new NBTTagCompound();
|
||||
entity.writeToNBT(nbt);
|
||||
nbtId = entityNbtMap.resolve(namespacedId, nbt);
|
||||
final long packed = ((currentTick & 0x7FFFFFFFL) << 32) | (nbtId & 0xFFFFFFFFL);
|
||||
entityNbtCache.put(entityRuntimeId, packed);
|
||||
while (entityNbtCache.size() > ENTITY_NBT_CACHE_MAX) {
|
||||
entityNbtCache.removeFirstLong();
|
||||
}
|
||||
}
|
||||
|
||||
if (nbtId != -1) {
|
||||
return nbtId;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Normal entity type lookup
|
||||
int normalId = getNormalEntityId(entity, entityIdMap);
|
||||
final int normalId = getNormalEntityId(entity, entityIdMap);
|
||||
|
||||
// Check for special entity type overrides
|
||||
int specialId = getSpecialEntityId(entity, entityIdMap);
|
||||
final int specialId = getSpecialEntityId(entity, entityIdMap);
|
||||
if (specialId != -1) {
|
||||
return specialId;
|
||||
}
|
||||
@@ -134,4 +177,24 @@ public final class EntityIdHelper {
|
||||
|
||||
return id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a cached NamespacedId for the entity's registered type.
|
||||
*/
|
||||
private static NamespacedId getCachedEntityName(Entity entity) {
|
||||
Class<?> entityClass = entity.getClass();
|
||||
NamespacedId cached = entityNameCache.get(entityClass);
|
||||
if (cached != null) {
|
||||
return cached;
|
||||
}
|
||||
|
||||
String entityType = EntityList.getEntityString(entity);
|
||||
if (entityType == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
cached = new NamespacedId(entityType);
|
||||
entityNameCache.put(entityClass, cached);
|
||||
return cached;
|
||||
}
|
||||
}
|
||||
@@ -6,6 +6,7 @@ import it.unimi.dsi.fastutil.objects.Object2IntFunction;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
|
||||
import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
|
||||
import net.coderbot.iris.block_rendering.BlockRenderingSettings;
|
||||
import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
|
||||
import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.item.Item;
|
||||
@@ -20,6 +21,7 @@ import net.minecraft.util.ResourceLocation;
|
||||
public class ItemMaterialHelper {
|
||||
private static final Reference2ObjectMap<Item, Int2IntMap> MATERIAL_CACHE = new Reference2ObjectOpenHashMap<>();
|
||||
private static final int CACHE_MISS_SENTINEL = Integer.MIN_VALUE;
|
||||
private static final Reference2ObjectMap<Item, NamespacedId> ITEM_NAME_CACHE = new Reference2ObjectOpenHashMap<>();
|
||||
/**
|
||||
* Get the material ID for an ItemStack.
|
||||
* For ItemBlock: checks block.properties first, then item.properties.
|
||||
@@ -32,6 +34,19 @@ public class ItemMaterialHelper {
|
||||
if (itemStack == null || itemStack.getItem() == null) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Check item NBT conditions first
|
||||
final NbtConditionalIdMap<NamespacedId> itemNbtMap = BlockRenderingSettings.INSTANCE.getItemNbtMap();
|
||||
if (itemNbtMap != null && !itemNbtMap.isEmpty() && itemStack.hasTagCompound()) {
|
||||
NamespacedId namespacedId = getCachedItemName(itemStack.getItem());
|
||||
if (namespacedId != null && itemNbtMap.hasConditions(namespacedId)) {
|
||||
int nbtId = itemNbtMap.resolve(namespacedId, itemStack.getTagCompound());
|
||||
if (nbtId != -1) {
|
||||
return nbtId;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return getMaterialId(itemStack.getItem(), itemStack.getItemDamage());
|
||||
}
|
||||
|
||||
@@ -73,8 +88,7 @@ public class ItemMaterialHelper {
|
||||
*/
|
||||
private static int lookupMaterialId(Item item, int metadata) {
|
||||
// For ItemBlock: check block.properties first
|
||||
if (item instanceof ItemBlock) {
|
||||
final ItemBlock itemBlock = (ItemBlock) item;
|
||||
if (item instanceof ItemBlock itemBlock) {
|
||||
final Block block = itemBlock.field_150939_a; // The block this item places
|
||||
|
||||
if (block != null) {
|
||||
@@ -94,7 +108,7 @@ public class ItemMaterialHelper {
|
||||
// Fall back to item.properties
|
||||
Object2IntFunction<NamespacedId> itemIds = BlockRenderingSettings.INSTANCE.getItemIds();
|
||||
if (itemIds != null) {
|
||||
String itemIdString = (String) Item.itemRegistry.getNameForObject(item);
|
||||
String itemIdString = Item.itemRegistry.getNameForObject(item);
|
||||
if (itemIdString != null) {
|
||||
ResourceLocation itemId = new ResourceLocation(itemIdString);
|
||||
return itemIds.applyAsInt(new NamespacedId(itemId.getResourceDomain(), itemId.getResourcePath()));
|
||||
@@ -110,5 +124,23 @@ public class ItemMaterialHelper {
|
||||
*/
|
||||
public static void clearCache() {
|
||||
MATERIAL_CACHE.clear();
|
||||
ITEM_NAME_CACHE.clear();
|
||||
}
|
||||
|
||||
private static NamespacedId getCachedItemName(Item item) {
|
||||
NamespacedId cached = ITEM_NAME_CACHE.get(item);
|
||||
if (cached != null) {
|
||||
return cached;
|
||||
}
|
||||
|
||||
String itemIdString = Item.itemRegistry.getNameForObject(item);
|
||||
if (itemIdString == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
ResourceLocation itemId = new ResourceLocation(itemIdString);
|
||||
cached = new NamespacedId(itemId.getResourceDomain(), itemId.getResourcePath());
|
||||
ITEM_NAME_CACHE.put(item, cached);
|
||||
return cached;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user