From f00b35a017688248908d6b615b1cbbbd5b210752 Mon Sep 17 00:00:00 2001 From: aidancbrady Date: Fri, 5 Aug 2016 16:44:30 -0400 Subject: [PATCH] Fixed Infusing Factory losing infuse storage, implement CTM model caching --- .../java/mekanism/client/render/ctm/CTM.java | 28 ++- .../render/ctm/CTMBlockRenderContext.java | 27 +++ .../client/render/ctm/CTMConnections.java | 182 ++++++++++++++++++ .../client/render/ctm/CTMModelFactory.java | 103 ++++++---- .../client/render/ctm/CTMRegistry.java | 4 +- .../java/mekanism/client/render/ctm/Dir.java | 2 +- .../common/tile/TileEntityFactory.java | 1 + .../tile/TileEntityMetallurgicInfuser.java | 3 +- 8 files changed, 311 insertions(+), 39 deletions(-) create mode 100644 src/main/java/mekanism/client/render/ctm/CTMConnections.java diff --git a/src/main/java/mekanism/client/render/ctm/CTM.java b/src/main/java/mekanism/client/render/ctm/CTM.java index 78dd81c7f..e3cbb0ec6 100644 --- a/src/main/java/mekanism/client/render/ctm/CTM.java +++ b/src/main/java/mekanism/client/render/ctm/CTM.java @@ -12,6 +12,7 @@ import gnu.trove.map.TIntObjectMap; import gnu.trove.map.hash.TIntObjectHashMap; import java.util.EnumMap; +import java.util.List; import net.minecraft.block.state.IBlockState; import net.minecraft.util.EnumFacing; @@ -157,6 +158,19 @@ public class CTM { return submapCache; } + public int[] createSubmapIndices(long data, EnumFacing side){ + submapCache = new int[] { 18, 19, 17, 16 }; + + buildConnectionMap(data, side); + + // Map connections to submap indeces + for (int i = 0; i < 4; i++) { + fillSubmaps(i); + } + + return submapCache; + } + public int[] getSubmapIndices() { return submapCache; } @@ -174,6 +188,18 @@ public class CTM { connectionMap.put(dir, dir.isConnected(this, world, pos, side, state)); } } + + public void buildConnectionMap(long data, EnumFacing side){ + for (Dir dir : Dir.VALUES){ + connectionMap.put(dir, false); + } + List connections = CTMConnections.decode(data); + for (CTMConnections loc : connections){ + if (loc.getDirForSide(side) != null){ + connectionMap.put(loc.getDirForSide(side), true); + } + } + } private void fillSubmaps(int idx) { Dir[] dirs = submapMap.get(idx); @@ -298,7 +324,7 @@ public class CTM { return ret; } - public IBlockState getBlockOrFacade(IBlockAccess world, BlockPos pos, EnumFacing side) { + public static IBlockState getBlockOrFacade(IBlockAccess world, BlockPos pos, EnumFacing side) { IBlockState state = world.getBlockState(pos); return state; } diff --git a/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java b/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java index 624d3483a..26e437bee 100644 --- a/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java +++ b/src/main/java/mekanism/client/render/ctm/CTMBlockRenderContext.java @@ -6,9 +6,17 @@ import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; import net.minecraft.world.IBlockAccess; +import org.apache.commons.lang3.ArrayUtils; + +import static mekanism.client.render.ctm.CTMConnections.*; + public class CTMBlockRenderContext { + private static final CTMConnections[] CACHED_LOCATIONS = ArrayUtils.removeElements(CTMConnections.VALUES, UP_UP, DOWN_DOWN, EAST_EAST, WEST_WEST, NORTH_NORTH, SOUTH_SOUTH); + private EnumMap ctmData = new EnumMap<>(EnumFacing.class); + + private long data; public CTMBlockRenderContext(IBlockAccess world, BlockPos pos) { @@ -18,6 +26,20 @@ public class CTMBlockRenderContext ctm.createSubmapIndices(world, pos, face); ctmData.put(face, ctm); } + + data = CTMConnections.getData(world, pos, CACHED_LOCATIONS); + } + + public CTMBlockRenderContext(long d) + { + data = d; + + for(EnumFacing face : EnumFacing.VALUES) + { + CTM ctm = createCTM(); + ctm.createSubmapIndices(data, face); + ctmData.put(face, ctm); + } } protected CTM createCTM() @@ -29,4 +51,9 @@ public class CTMBlockRenderContext { return ctmData.get(face); } + + public long serialize() + { + return data; + } } diff --git a/src/main/java/mekanism/client/render/ctm/CTMConnections.java b/src/main/java/mekanism/client/render/ctm/CTMConnections.java new file mode 100644 index 000000000..3a3d718a9 --- /dev/null +++ b/src/main/java/mekanism/client/render/ctm/CTMConnections.java @@ -0,0 +1,182 @@ +package mekanism.client.render.ctm; + +import java.util.ArrayList; +import java.util.List; + +import mekanism.api.MekanismAPI; +import net.minecraft.block.state.IBlockState; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IBlockAccess; + +/** + * Represents all the different spot for connection locations for a ctm block + */ +public enum CTMConnections +{ + UP(Dir.TOP), + DOWN(Dir.BOTTOM), + NORTH(EnumFacing.EAST, Dir.RIGHT), + SOUTH(EnumFacing.EAST, Dir.LEFT), + EAST(Dir.RIGHT), + WEST(Dir.LEFT), + + NORTH_EAST(EnumFacing.UP, Dir.TOP_RIGHT), + NORTH_WEST(EnumFacing.UP, Dir.TOP_LEFT), + SOUTH_EAST(EnumFacing.UP, Dir.BOTTOM_RIGHT), + SOUTH_WEST(EnumFacing.UP, Dir.BOTTOM_LEFT), + + NORTH_UP(EnumFacing.EAST, Dir.TOP_RIGHT), + NORTH_DOWN(EnumFacing.EAST, Dir.BOTTOM_RIGHT), + SOUTH_UP(EnumFacing.EAST, Dir.TOP_LEFT), + SOUTH_DOWN(EnumFacing.EAST, Dir.BOTTOM_LEFT), + + EAST_UP(Dir.TOP_RIGHT), + EAST_DOWN(Dir.BOTTOM_RIGHT), + WEST_UP(Dir.TOP_LEFT), + WEST_DOWN(Dir.BOTTOM_LEFT), + + NORTH_EAST_UP(EnumFacing.EAST, Dir.TOP_RIGHT, true), + NORTH_EAST_DOWN(EnumFacing.EAST, Dir.BOTTOM_RIGHT, true), + + SOUTH_EAST_UP(EnumFacing.EAST, Dir.TOP_LEFT, true), + SOUTH_EAST_DOWN(EnumFacing.EAST, Dir.BOTTOM_LEFT, true), + + SOUTH_WEST_UP(EnumFacing.WEST, Dir.TOP_LEFT, true), + SOUTH_WEST_DOWN(EnumFacing.WEST, Dir.BOTTOM_LEFT, true), + + NORTH_WEST_UP(EnumFacing.WEST, Dir.TOP_RIGHT, true), + NORTH_WEST_DOWN(EnumFacing.WEST, Dir.BOTTOM_RIGHT, true), + + UP_UP(EnumFacing.UP, null, true), + DOWN_DOWN(EnumFacing.DOWN, null, true), + NORTH_NORTH(EnumFacing.NORTH, null, true), + SOUTH_SOUTH(EnumFacing.SOUTH, null, true), + EAST_EAST(EnumFacing.EAST, null, true), + WEST_WEST(EnumFacing.WEST, null, true), + + ; + + public static final CTMConnections[] VALUES = values(); + + /** + * The enum facing directions needed to get to this connection location + */ + private EnumFacing normal; + private Dir dir; + private boolean offset; + + private CTMConnections(Dir dir) { + this(EnumFacing.SOUTH, dir); + } + + private CTMConnections(Dir dir, boolean offset) { + this(EnumFacing.SOUTH, dir, offset); + } + + private CTMConnections(EnumFacing normal, Dir dir){ + this(normal, dir, false); + } + + private CTMConnections(EnumFacing normal, Dir dir, boolean offset) { + this.normal = normal; + this.dir = dir; + this.offset = offset; + } + + public Dir getDirForSide(EnumFacing facing){ + return dir == null ? null : dir;//TODO .relativize() + } + + public EnumFacing clipOrDestroy(EnumFacing direction) { + EnumFacing[] dirs = dir == null ? new EnumFacing[] {normal, normal} : dir.getNormalizedDirs(direction); + if (dirs[0] == direction) { + return dirs.length > 1 ? dirs[1] : null; + } else if (dirs.length > 1 && dirs[1] == direction) { + return dirs[0]; + } else { + return null; + } + } + + public BlockPos transform(BlockPos pos) { + if (dir != null) { + for (EnumFacing facing : dir.getNormalizedDirs(normal)) { + pos = pos.offset(facing); + } + } else { + pos = pos.offset(normal); + } + + if (offset) { + pos = pos.offset(normal); + } + return pos; + } + + public static CTMConnections fromFacing(EnumFacing facing){ + switch (facing){ + case NORTH: return NORTH; + case SOUTH: return SOUTH; + case EAST: return EAST; + case WEST: return WEST; + case UP: return UP; + case DOWN: return DOWN; + default: return NORTH; + } + } + + public static EnumFacing toFacing(CTMConnections loc){ + switch (loc){ + case NORTH: return EnumFacing.NORTH; + case SOUTH: return EnumFacing.SOUTH; + case EAST: return EnumFacing.EAST; + case WEST: return EnumFacing.WEST; + case UP: return EnumFacing.UP; + case DOWN: return EnumFacing.DOWN; + default: return EnumFacing.NORTH; + } + } + + public static List decode(long data) { + List list = new ArrayList<>(); + for (CTMConnections loc : values()) { + if ((1 & (data >> loc.ordinal())) != 0) { + list.add(loc); + } + } + return list; + } + + public long getMask(){ + return 1 << ordinal(); + } + + public static List getConnections(IBlockAccess world, BlockPos pos, CTMConnections[] values){ + List locs = new ArrayList<>(); + IBlockState state = world.getBlockState(pos); + for (CTMConnections loc : values) { + BlockPos second = loc.transform(pos); + if (state.equals(CTM.getBlockOrFacade(world, second, null))){ + locs.add(loc); + } + } + return locs; + } + + public static long getData(IBlockAccess world, BlockPos pos, CTMConnections[] values){ + List locs = getConnections(world, pos, values); + long data = 0; + for (CTMConnections loc : locs){ + data = data | loc.getMask(); + } + if (MekanismAPI.debug) { + String s = Long.toBinaryString(data); + while (s.length() < 32) { + s = "0" + s; + } + System.out.println(pos + ": " + s); + } + return data; + } +} \ No newline at end of file diff --git a/src/main/java/mekanism/client/render/ctm/CTMModelFactory.java b/src/main/java/mekanism/client/render/ctm/CTMModelFactory.java index ba35df7f8..274bb9119 100644 --- a/src/main/java/mekanism/client/render/ctm/CTMModelFactory.java +++ b/src/main/java/mekanism/client/render/ctm/CTMModelFactory.java @@ -1,8 +1,10 @@ package mekanism.client.render.ctm; -import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.Objects; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; import javax.annotation.Nullable; import javax.vecmath.Matrix4f; @@ -20,43 +22,48 @@ import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.entity.EntityLivingBase; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import net.minecraft.util.BlockRenderLayer; import net.minecraft.util.EnumFacing; import net.minecraft.world.World; +import net.minecraftforge.client.MinecraftForgeClient; import net.minecraftforge.client.model.IPerspectiveAwareModel; import net.minecraftforge.common.model.TRSRTransformation; import net.minecraftforge.common.property.IExtendedBlockState; import org.apache.commons.lang3.tuple.Pair; +import com.google.common.cache.Cache; +import com.google.common.cache.CacheBuilder; import com.google.common.collect.FluentIterable; +import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ListMultimap; import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.MultimapBuilder; +import com.google.common.collect.Table; +import com.google.common.collect.Tables; /** - * Model for all chisel blocks + * Model for all CTM blocks, credit to Chisel */ @SuppressWarnings("deprecation") public class CTMModelFactory implements IPerspectiveAwareModel { - private List face; - private List general; + private ListMultimap genQuads = MultimapBuilder.enumKeys(BlockRenderLayer.class).arrayListValues().build(); + private Table> faceQuads = Tables.newCustomTable(Maps.newEnumMap(BlockRenderLayer.class), () -> Maps.newEnumMap(EnumFacing.class)); private ModelCTM model; private CTMOverride override = new CTMOverride(); - public CTMModelFactory(List f, List g, ModelCTM m) + public CTMModelFactory(ModelCTM m) { - face = f; - general = g; model = m; } - - public CTMModelFactory(ModelCTM model) - { - this(Collections.emptyList(), Collections.emptyList(), model); - } - + + private static Cache ctmCache = CacheBuilder.newBuilder().expireAfterAccess(1, TimeUnit.MINUTES).maximumSize(500).build(); + @Override public List getQuads(IBlockState stateIn, EnumFacing side, long rand) { @@ -65,14 +72,29 @@ public class CTMModelFactory implements IPerspectiveAwareModel if(stateIn != null && stateIn.getBlock() instanceof ICTMBlock && stateIn instanceof IExtendedBlockState) { IExtendedBlockState state = (IExtendedBlockState)stateIn; + IBlockState clean = state.getClean(); CTMBlockRenderContext ctxList = state.getValue(BlockStateBasic.ctmProperty); - baked = createModel(stateIn, model, ctxList); + + try { + if(ctxList == null) + { + baked = ctmCache.get(Objects.hash(clean, -1), () -> createModel(state, model, null)); + } + else { + long serialized = ctxList.serialize(); + baked = ctmCache.get(Objects.hash(clean, serialized), () -> createModel(state, model, ctxList)); + } + } catch(Exception e) { + e.printStackTrace(); + return Lists.newArrayList(); + } } else { baked = this; } - return side == null ? baked.general : FluentIterable.from(baked.face).filter(quad -> quad.getFace() == side).toList(); + BlockRenderLayer layer = MinecraftForgeClient.getRenderLayer(); + return side == null ? baked.genQuads.get(layer) : layer == null ? baked.faceQuads.column(side).values().stream().flatMap(List::stream).collect(Collectors.toList()) : baked.faceQuads.get(layer, side); } @Override @@ -107,33 +129,48 @@ public class CTMModelFactory implements IPerspectiveAwareModel private CTMModelFactory createModel(IBlockState state, ModelCTM model, CTMBlockRenderContext ctx) { - List faceQuads = Lists.newArrayList(); - List generalQuads = Lists.newArrayList(); + CTMModelFactory ret = new CTMModelFactory(model); + IBakedModel baked = model.getModel(state); + int quadGoal = ctx == null ? 1 : CTM.QUADS_PER_SIDE; + List quads = Lists.newArrayList(); - for(EnumFacing facing : EnumFacing.VALUES) + for(BlockRenderLayer layer : BlockRenderLayer.values()) { - TextureCTM face = model.getFace(facing); - ICTMBlock block = (ICTMBlock)state.getBlock(); - CTMData data = block.getCTMData(state); - - if(block.getOverrideTexture(state, facing) != null) - { - face = CTMRegistry.textureCache.get(block.getOverrideTexture(state, facing)); - } + for(EnumFacing facing : EnumFacing.VALUES) + { + TextureCTM face = model.getFace(facing); + + if(ctx == null || layer == face.layer) + { + ICTMBlock block = (ICTMBlock)state.getBlock(); + CTMData data = block.getCTMData(state); + + if(block.getOverrideTexture(state, facing) != null) + { + face = CTMRegistry.textureCache.get(block.getOverrideTexture(state, facing)); + } - int quadGoal = ctx == null ? 1 : CTM.QUADS_PER_SIDE; - IBakedModel baked = model.getModel(state); - List origFaceQuads = baked.getQuads(state, facing, 0); - List origGeneralQuads = FluentIterable.from(baked.getQuads(state, null, 0)).filter(q -> q.getFace() == facing).toList(); - addAllQuads(origFaceQuads, face, ctx, state, quadGoal, faceQuads); - addAllQuads(origGeneralQuads, face, ctx, state, quadGoal, generalQuads); + List temp = baked.getQuads(state, facing, 0); + addAllQuads(temp, face, ctx, state, quadGoal, quads); + ret.faceQuads.put(layer, facing, ImmutableList.copyOf(quads)); + + temp = FluentIterable.from(baked.getQuads(state, null, 0)).filter(q -> q.getFace() == facing).toList(); + addAllQuads(temp, face, ctx, state, quadGoal, quads); + ret.genQuads.putAll(layer, temp); + } + else { + ret.faceQuads.put(layer, facing, Lists.newArrayList()); + } + } } - return new CTMModelFactory(faceQuads, generalQuads, model); + return ret; } private void addAllQuads(List from, TextureCTM tex, @Nullable CTMBlockRenderContext ctx, IBlockState state, int quadGoal, List to) { + to.clear(); + for(BakedQuad q : from) { to.addAll(tex.transformQuad(q, ctx == null ? null : ctx, quadGoal)); diff --git a/src/main/java/mekanism/client/render/ctm/CTMRegistry.java b/src/main/java/mekanism/client/render/ctm/CTMRegistry.java index 284ef222c..f1991c34e 100644 --- a/src/main/java/mekanism/client/render/ctm/CTMRegistry.java +++ b/src/main/java/mekanism/client/render/ctm/CTMRegistry.java @@ -75,10 +75,10 @@ public class CTMRegistry callbacks[0] = new TextureSpriteCallback(new ResourceLocation(domain + ":blocks/ctm/" + name)); callbacks[1] = new TextureSpriteCallback(new ResourceLocation(domain + ":blocks/ctm/" + name + "-ctm")); - + register(callbacks[0]); register(callbacks[1]); - return new TextureCTM(BlockRenderLayer.SOLID, callbacks); + return new TextureCTM(BlockRenderLayer.CUTOUT, callbacks); } } diff --git a/src/main/java/mekanism/client/render/ctm/Dir.java b/src/main/java/mekanism/client/render/ctm/Dir.java index b33d38458..f82c8f05d 100644 --- a/src/main/java/mekanism/client/render/ctm/Dir.java +++ b/src/main/java/mekanism/client/render/ctm/Dir.java @@ -90,7 +90,7 @@ public enum Dir { return connection; } - private EnumFacing[] getNormalizedDirs(EnumFacing normal) { + public EnumFacing[] getNormalizedDirs(EnumFacing normal) { if (normal == NORMAL) { return dirs; } else if (normal == NORMAL.getOpposite()) { diff --git a/src/main/java/mekanism/common/tile/TileEntityFactory.java b/src/main/java/mekanism/common/tile/TileEntityFactory.java index b81896bda..3a157f142 100644 --- a/src/main/java/mekanism/common/tile/TileEntityFactory.java +++ b/src/main/java/mekanism/common/tile/TileEntityFactory.java @@ -232,6 +232,7 @@ public class TileEntityFactory extends TileEntityNoisyElectricBlock implements I factory.recipeType = recipeType; factory.upgradeComponent.setSupported(Upgrade.GAS, recipeType.fuelEnergyUpgrades()); factory.securityComponent.readFrom(securityComponent); + factory.infuseStored = infuseStored; for(int i = 0; i < tier.processes+5; i++) { diff --git a/src/main/java/mekanism/common/tile/TileEntityMetallurgicInfuser.java b/src/main/java/mekanism/common/tile/TileEntityMetallurgicInfuser.java index f5a6c9756..80ad13a3c 100644 --- a/src/main/java/mekanism/common/tile/TileEntityMetallurgicInfuser.java +++ b/src/main/java/mekanism/common/tile/TileEntityMetallurgicInfuser.java @@ -255,8 +255,7 @@ public class TileEntityMetallurgicInfuser extends TileEntityNoisyElectricBlock i } //Infuser - factory.infuseStored.amount = infuseStored.amount; - factory.infuseStored.type = infuseStored.type; + factory.infuseStored = infuseStored; factory.inventory[5] = inventory[2]; factory.inventory[1] = inventory[4];