dave/refinedstorage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add hollow covers.

Browse Source
This commit is contained in:
raoulvdberge
2018-07-06 23:27:11 +02:00
parent 7009eb883e
commit fc498e6400
16 changed files with 524 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/java/com/raoulvdberge/refinedstorage/RSItems.java
View File

@@ -22,4 +22,5 @@ public final class RSItems {
public static final ItemSecurityCard SECURITY_CARD = new ItemSecurityCard();
public static final ItemCuttingTool CUTTING_TOOL = new ItemCuttingTool();
public static final ItemCover COVER = new ItemCover();
public static final ItemHollowCover HOLLOW_COVER = new ItemHollowCover();
}

21
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/Cover.java Normal file
View File

@@ -0,0 +1,21 @@
package com.raoulvdberge.refinedstorage.apiimpl.network.node.cover;
import net.minecraft.item.ItemStack;
public class Cover {
private ItemStack stack;
private boolean hollow;
public Cover(ItemStack stack, boolean hollow) {
this.stack = stack;
this.hollow = hollow;
}
public ItemStack getStack() {
return stack;
}
public boolean isHollow() {
return hollow;
}
}

48
src/main/java/com/raoulvdberge/refinedstorage/apiimpl/network/node/cover/CoverManager.java
View File

@@ -27,8 +27,9 @@ import java.util.Map;
public class CoverManager {
private static final String NBT_DIRECTION = "Direction";
private static final String NBT_ITEM = "Item";
private static final String NBT_HOLLOW = "Hollow";
private Map<EnumFacing, ItemStack> covers = new HashMap<>();
private Map<EnumFacing, Cover> covers = new HashMap<>();
private NetworkNode node;
private boolean canPlaceCoversOnFace = true;
@@ -37,20 +38,25 @@ public class CoverManager {
}
public boolean canConduct(EnumFacing direction) {
if (hasCover(direction)) {
Cover cover = getCover(direction);
if (cover != null && !cover.isHollow()) {
return false;
}
INetworkNode neighbor = API.instance().getNetworkNodeManager(node.getWorld()).getNode(node.getPos().offset(direction));
if (neighbor instanceof ICoverable && ((ICoverable) neighbor).getCoverManager().hasCover(direction.getOpposite())) {
if (neighbor instanceof ICoverable) {
cover = ((ICoverable) neighbor).getCoverManager().getCover(direction.getOpposite());
if (cover != null && !cover.isHollow()) {
return false;
}
}
return true;
}
@Nullable
public ItemStack getCover(EnumFacing facing) {
public Cover getCover(EnumFacing facing) {
return covers.get(facing);
}
@@ -58,13 +64,13 @@ public class CoverManager {
return covers.containsKey(facing);
}
public boolean setCover(EnumFacing facing, ItemStack stack) {
if (isValidCover(stack) && !hasCover(facing)) {
if (facing == node.getDirection() && !canPlaceCoversOnFace) {
public boolean setCover(EnumFacing facing, Cover cover) {
if (isValidCover(cover.getStack()) && !hasCover(facing)) {
if (facing == node.getDirection() && !canPlaceCoversOnFace && !cover.isHollow()) {
return false;
}
covers.put(facing, stack);
covers.put(facing, cover);
node.markDirty();
@@ -78,12 +84,6 @@ public class CoverManager {
return false;
}
public CoverManager setCanPlaceCoversOnFace(boolean canPlaceCoversOnFace) {
this.canPlaceCoversOnFace = canPlaceCoversOnFace;
return this;
}
public void readFromNbt(NBTTagList list) {
for (int i = 0; i < list.tagCount(); ++i) {
NBTTagCompound tag = list.getCompoundTagAt(i);
@@ -91,9 +91,10 @@ public class CoverManager {
if (tag.hasKey(NBT_DIRECTION) && tag.hasKey(NBT_ITEM)) {
EnumFacing direction = EnumFacing.getFront(tag.getInteger(NBT_DIRECTION));
ItemStack item = new ItemStack(tag.getCompoundTag(NBT_ITEM));
boolean hollow = tag.hasKey(NBT_HOLLOW) && tag.getBoolean(NBT_HOLLOW);
if (isValidCover(item)) {
covers.put(direction, item);
covers.put(direction, new Cover(item, hollow));
}
}
}
@@ -102,11 +103,12 @@ public class CoverManager {
public NBTTagList writeToNbt() {
NBTTagList list = new NBTTagList();
for (Map.Entry<EnumFacing, ItemStack> entry : covers.entrySet()) {
for (Map.Entry<EnumFacing, Cover> entry : covers.entrySet()) {
NBTTagCompound tag = new NBTTagCompound();
tag.setInteger(NBT_DIRECTION, entry.getKey().ordinal());
tag.setTag(NBT_ITEM, entry.getValue().serializeNBT());
tag.setTag(NBT_ITEM, entry.getValue().getStack().serializeNBT());
tag.setBoolean(NBT_HOLLOW, entry.getValue().isHollow());
list.appendTag(tag);
}
@@ -119,10 +121,10 @@ public class CoverManager {
int i = 0;
for (Map.Entry<EnumFacing, ItemStack> entry : covers.entrySet()) {
ItemStack cover = new ItemStack(RSItems.COVER);
for (Map.Entry<EnumFacing, Cover> entry : covers.entrySet()) {
ItemStack cover = new ItemStack(entry.getValue().isHollow() ? RSItems.HOLLOW_COVER : RSItems.COVER);
ItemCover.setItem(cover, entry.getValue());
ItemCover.setItem(cover, entry.getValue().getStack());
handler.setStackInSlot(i++, cover);
}
@@ -181,4 +183,10 @@ public class CoverManager {
return null;
}
}
public CoverManager setCanPlaceCoversOnFace(boolean canPlaceCoversOnFace) {
this.canPlaceCoversOnFace = canPlaceCoversOnFace;
return this;
}
}

87
src/main/java/com/raoulvdberge/refinedstorage/block/BlockCable.java
View File

@@ -2,6 +2,7 @@ package com.raoulvdberge.refinedstorage.block;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.ICoverable;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.capability.CapabilityNetworkNodeProxy;
import com.raoulvdberge.refinedstorage.tile.TileBase;
@@ -14,7 +15,6 @@ import net.minecraft.block.state.BlockStateContainer;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockRenderLayer;
import net.minecraft.util.EnumFacing;
@@ -31,12 +31,12 @@ import java.util.ArrayList;
import java.util.List;
public class BlockCable extends BlockNode {
public static final PropertyObject<ItemStack> COVER_NORTH = new PropertyObject<>("cover_north", ItemStack.class);
public static final PropertyObject<ItemStack> COVER_EAST = new PropertyObject<>("cover_east", ItemStack.class);
public static final PropertyObject<ItemStack> COVER_SOUTH = new PropertyObject<>("cover_south", ItemStack.class);
public static final PropertyObject<ItemStack> COVER_WEST = new PropertyObject<>("cover_west", ItemStack.class);
public static final PropertyObject<ItemStack> COVER_UP = new PropertyObject<>("cover_up", ItemStack.class);
public static final PropertyObject<ItemStack> COVER_DOWN = new PropertyObject<>("cover_down", ItemStack.class);
public static final PropertyObject<Cover> COVER_NORTH = new PropertyObject<>("cover_north", Cover.class);
public static final PropertyObject<Cover> COVER_EAST = new PropertyObject<>("cover_east", Cover.class);
public static final PropertyObject<Cover> COVER_SOUTH = new PropertyObject<>("cover_south", Cover.class);
public static final PropertyObject<Cover> COVER_WEST = new PropertyObject<>("cover_west", Cover.class);
public static final PropertyObject<Cover> COVER_UP = new PropertyObject<>("cover_up", Cover.class);
public static final PropertyObject<Cover> COVER_DOWN = new PropertyObject<>("cover_down", Cover.class);
public static final AxisAlignedBB HOLDER_NORTH_AABB = RenderUtils.getBounds(7, 7, 2, 9, 9, 6);
public static final AxisAlignedBB HOLDER_EAST_AABB = RenderUtils.getBounds(10, 7, 7, 14, 9, 9);
@@ -136,16 +136,20 @@ public class BlockCable extends BlockNode {
INetworkNode node = ((TileNode) tile).getNode();
if (node instanceof ICoverable && ((ICoverable) node).getCoverManager().hasCover(direction)) {
if (node instanceof ICoverable) {
Cover cover = ((ICoverable) node).getCoverManager().getCover(direction);
if (cover != null && !cover.isHollow()) {
return false;
}
}
TileEntity otherTile = world.getTileEntity(pos.offset(direction));
if (otherTile instanceof TileNode) {
INetworkNode otherNode = ((TileNode) otherTile).getNode();
if (otherTile instanceof TileNode && ((TileNode) otherTile).getNode() instanceof ICoverable) {
Cover cover = ((ICoverable) ((TileNode) otherTile).getNode()).getCoverManager().getCover(direction.getOpposite());
if (otherNode instanceof ICoverable && ((ICoverable) otherNode).getCoverManager().hasCover(direction.getOpposite())) {
if (cover != null && !cover.isHollow()) {
return false;
}
}
@@ -229,66 +233,79 @@ public class BlockCable extends BlockNode {
if (tile instanceof TileNode && ((TileNode) tile).getNode() instanceof ICoverable) {
CoverManager coverManager = ((ICoverable) ((TileNode) tile).getNode()).getCoverManager();
boolean hasUp = coverManager.hasCover(EnumFacing.UP);
boolean hasDown = coverManager.hasCover(EnumFacing.DOWN);
Cover coverNorth = coverManager.getCover(EnumFacing.NORTH);
Cover coverEast = coverManager.getCover(EnumFacing.EAST);
Cover coverSouth = coverManager.getCover(EnumFacing.SOUTH);
Cover coverWest = coverManager.getCover(EnumFacing.WEST);
Cover coverUp = coverManager.getCover(EnumFacing.UP);
Cover coverDown = coverManager.getCover(EnumFacing.DOWN);
boolean hasEast = coverManager.hasCover(EnumFacing.EAST);
boolean hasWest = coverManager.hasCover(EnumFacing.WEST);
if (coverManager.hasCover(EnumFacing.NORTH)) {
if (coverNorth != null) {
boxes.add(RenderUtils.getBounds(
hasWest ? 2 : 0, hasDown ? 2 : 0, 0,
hasEast ? 14 : 16, hasUp ? 14 : 16, 2
coverWest != null ? 2 : 0, coverDown != null ? 2 : 0, 0,
coverEast != null ? 14 : 16, coverUp != null ? 14 : 16, 2
));
if (!coverNorth.isHollow()) {
boxes.add(HOLDER_NORTH_AABB);
}
}
if (hasEast) {
if (coverEast != null) {
boxes.add(RenderUtils.getBounds(
14, hasDown ? 2 : 0, 0,
16, hasUp ? 14 : 16, 16
14, coverDown != null ? 2 : 0, 0,
16, coverUp != null ? 14 : 16, 16
));
if (!coverEast.isHollow()) {
boxes.add(HOLDER_EAST_AABB);
}
}
if (coverManager.hasCover(EnumFacing.SOUTH)) {
if (coverSouth != null) {
boxes.add(RenderUtils.getBounds(
hasEast ? 14 : 16, hasDown ? 2 : 0, 16,
hasWest ? 2 : 0, hasUp ? 14 : 16, 14
coverEast != null ? 14 : 16, coverDown != null ? 2 : 0, 16,
coverWest != null ? 2 : 0, coverUp != null ? 14 : 16, 14
));
if (!coverSouth.isHollow()) {
boxes.add(HOLDER_SOUTH_AABB);
}
if (hasWest) {
boxes.add(RenderUtils.getBounds(
0, hasDown ? 2 : 0, 0,
2, hasUp ? 14 : 16, 16
));
boxes.add(HOLDER_WEST_AABB);
}
if (hasUp) {
if (coverWest != null) {
boxes.add(RenderUtils.getBounds(
0, coverDown != null ? 2 : 0, 0,
2, coverUp != null ? 14 : 16, 16
));
if (!coverWest.isHollow()) {
boxes.add(HOLDER_WEST_AABB);
}
}
if (coverUp != null) {
boxes.add(RenderUtils.getBounds(
0, 14, 0,
16, 16, 16
));
if (!coverUp.isHollow()) {
boxes.add(HOLDER_UP_AABB);
}
}
if (hasDown) {
if (coverDown != null) {
boxes.add(RenderUtils.getBounds(
0, 0, 0,
16, 2, 16
));
if (!coverDown.isHollow()) {
boxes.add(HOLDER_DOWN_AABB);
}
}
}
return boxes;
}

18
src/main/java/com/raoulvdberge/refinedstorage/item/ItemCover.java
View File

@@ -1,10 +1,10 @@
package com.raoulvdberge.refinedstorage.item;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.api.network.node.INetworkNode;
import com.raoulvdberge.refinedstorage.api.network.security.Permission;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.ICoverable;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.tile.TileNode;
import com.raoulvdberge.refinedstorage.util.WorldUtils;
@@ -31,12 +31,16 @@ import java.util.List;
public class ItemCover extends ItemBase {
private static final String NBT_ITEM = "Item";
public ItemCover() {
super("cover");
public ItemCover(String name) {
super(name);
setCreativeTab(RS.INSTANCE.coversTab);
}
public ItemCover() {
this("cover");
}
public static void setItem(ItemStack cover, ItemStack item) {
if (!cover.hasTagCompound()) {
cover.setTagCompound(new NBTTagCompound());
@@ -84,7 +88,7 @@ public class ItemCover extends ItemBase {
for (ItemStack subBlock : subBlocks) {
if (CoverManager.isValidCover(subBlock)) {
ItemStack stack = new ItemStack(RSItems.COVER);
ItemStack stack = new ItemStack(this);
setItem(stack, subBlock);
@@ -120,7 +124,7 @@ public class ItemCover extends ItemBase {
return EnumActionResult.FAIL;
}
if (((ICoverable) node).getCoverManager().setCover(facing, getItem(stack))) {
if (((ICoverable) node).getCoverManager().setCover(facing, createCover(getItem(stack)))) {
player.getHeldItem(hand).shrink(1);
WorldUtils.updateBlock(world, pos);
@@ -137,4 +141,8 @@ public class ItemCover extends ItemBase {
private boolean canPlaceOn(TileEntity tile) {
return tile instanceof TileNode && ((TileNode) tile).getNode() instanceof ICoverable;
}
protected Cover createCover(ItemStack stack) {
return new Cover(stack, false);
}
}

15
src/main/java/com/raoulvdberge/refinedstorage/item/ItemHollowCover.java Normal file
View File

@@ -0,0 +1,15 @@
package com.raoulvdberge.refinedstorage.item;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
import net.minecraft.item.ItemStack;
public class ItemHollowCover extends ItemCover {
public ItemHollowCover() {
super("hollow_cover");
}
@Override
protected Cover createCover(ItemStack stack) {
return new Cover(stack, true);
}
}

7
src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyClient.java
View File

@@ -18,8 +18,8 @@ import com.raoulvdberge.refinedstorage.network.MessageGridCraftingPreviewRespons
import com.raoulvdberge.refinedstorage.render.model.ModelDiskDrive;
import com.raoulvdberge.refinedstorage.render.model.ModelDiskManipulator;
import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCableCover;
import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCover;
import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelPattern;
import com.raoulvdberge.refinedstorage.render.model.loader.CustomModelLoaderCover;
import com.raoulvdberge.refinedstorage.render.model.loader.CustomModelLoaderDefault;
import com.raoulvdberge.refinedstorage.render.statemapper.StateMapperCTM;
import com.raoulvdberge.refinedstorage.render.tesr.TileEntitySpecialRendererStorageMonitor;
@@ -231,6 +231,7 @@ public class ProxyClient extends ProxyCommon {
ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RSBlocks.QUARTZ_ENRICHED_IRON), 0, new ModelResourceLocation("refinedstorage:quartz_enriched_iron_block", "inventory"));
ModelLoader.setCustomModelResourceLocation(Item.getItemFromBlock(RSBlocks.STORAGE_MONITOR), 0, new ModelResourceLocation("refinedstorage:storage_monitor", "connected=false,direction=north"));
ModelLoader.setCustomModelResourceLocation(RSItems.COVER, 0, new ModelResourceLocation("refinedstorage:cover", "inventory"));
ModelLoader.setCustomModelResourceLocation(RSItems.HOLLOW_COVER, 0, new ModelResourceLocation("refinedstorage:hollow_cover", "inventory"));
ModelLoaderRegistry.registerLoader(new CustomModelLoaderDefault(new ResourceLocation(RS.ID, "disk_drive"), ModelDiskDrive::new));
ModelLoaderRegistry.registerLoader(new CustomModelLoaderDefault(new ResourceLocation(RS.ID, "disk_manipulator"), ModelDiskManipulator::new));
@@ -292,6 +293,8 @@ public class ProxyClient extends ProxyCommon {
}
});
ModelLoaderRegistry.registerLoader(new CustomModelLoaderCover());
ModelLoader.setCustomStateMapper(RSBlocks.PORTABLE_GRID, new StateMap.Builder().ignore(BlockPortableGrid.TYPE).build());
ModelLoader.setCustomMeshDefinition(Item.getItemFromBlock(RSBlocks.PORTABLE_GRID), stack -> {
ItemHandlerBase disk = new ItemHandlerBase(1);
@@ -374,8 +377,6 @@ public class ProxyClient extends ProxyCommon {
e.getModelRegistry().putObject(model, new BakedModelPattern(e.getModelRegistry().getObject(model)));
} else if (model.getResourcePath().equals("cable") || model.getResourcePath().equals("exporter") || model.getResourcePath().equals("importer") || model.getResourcePath().equals("external_storage")) {
e.getModelRegistry().putObject(model, new BakedModelCableCover(e.getModelRegistry().getObject(model)));
} else if (model.getResourcePath().equals("cover")) {
e.getModelRegistry().putObject(model, new BakedModelCover(e.getModelRegistry().getObject(model), null));
}
}
}

3
src/main/java/com/raoulvdberge/refinedstorage/proxy/ProxyCommon.java
View File

@@ -43,6 +43,7 @@ import com.raoulvdberge.refinedstorage.integration.oc.IntegrationOC;
import com.raoulvdberge.refinedstorage.item.ItemProcessor;
import com.raoulvdberge.refinedstorage.network.*;
import com.raoulvdberge.refinedstorage.recipe.RecipeCover;
import com.raoulvdberge.refinedstorage.recipe.RecipeHollowCover;
import com.raoulvdberge.refinedstorage.tile.*;
import com.raoulvdberge.refinedstorage.tile.craftingmonitor.TileCraftingMonitor;
import com.raoulvdberge.refinedstorage.tile.data.TileDataManager;
@@ -263,6 +264,7 @@ public class ProxyCommon {
registerItem(RSItems.NETWORK_CARD);
registerItem(RSItems.SECURITY_CARD);
registerItem(RSItems.COVER);
registerItem(RSItems.HOLLOW_COVER);
IntegrationInventorySorter.register();
}
@@ -310,6 +312,7 @@ public class ProxyCommon {
@SubscribeEvent
public void registerRecipes(RegistryEvent.Register<IRecipe> e) {
e.getRegistry().register(new RecipeCover().setRegistryName(new ResourceLocation(RS.ID, "cover")));
e.getRegistry().register(new RecipeHollowCover().setRegistryName(new ResourceLocation(RS.ID, "hollow_cover")));
}
@SubscribeEvent

73
src/main/java/com/raoulvdberge/refinedstorage/recipe/RecipeHollowCover.java Normal file
View File

@@ -0,0 +1,73 @@
package com.raoulvdberge.refinedstorage.recipe;
import com.raoulvdberge.refinedstorage.RSItems;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.item.ItemCover;
import com.raoulvdberge.refinedstorage.item.ItemHollowCover;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.world.World;
import net.minecraftforge.registries.IForgeRegistryEntry;
import javax.annotation.Nullable;
public class RecipeHollowCover extends IForgeRegistryEntry.Impl<IRecipe> implements IRecipe {
private boolean isValid(ItemStack slot, @Nullable ItemStack previousValidSlot) {
ItemStack currentCover = ItemCover.getItem(slot);
if (slot.getItem() == RSItems.COVER && CoverManager.isValidCover(currentCover)) {
if (previousValidSlot == null) {
return true;
}
ItemStack previousCover = ItemCover.getItem(previousValidSlot);
return previousCover.getItem() == currentCover.getItem() && previousCover.getItemDamage() == currentCover.getItemDamage();
}
return false;
}
@Override
public boolean matches(InventoryCrafting inv, World worldIn) {
ItemStack previousValidSlot = null;
for (int i = 0; i < 9; ++i) {
ItemStack slot = inv.getStackInSlot(i);
if (i == 4) {
if (!slot.isEmpty()) {
return false;
}
} else {
if (isValid(slot, previousValidSlot)) {
previousValidSlot = slot;
} else {
return false;
}
}
}
return true;
}
@Override
public ItemStack getCraftingResult(InventoryCrafting inv) {
ItemStack stack = new ItemStack(RSItems.HOLLOW_COVER, 8);
ItemHollowCover.setItem(stack, ItemCover.getItem(inv.getStackInSlot(0)));
return stack;
}
@Override
public boolean canFit(int width, int height) {
return width == 3 && height == 3;
}
@Override
public ItemStack getRecipeOutput() {
return ItemStack.EMPTY;
}
}

24
src/main/java/com/raoulvdberge/refinedstorage/render/model/ModelCover.java Normal file
View File

@@ -0,0 +1,24 @@
package com.raoulvdberge.refinedstorage.render.model;
import com.raoulvdberge.refinedstorage.render.model.baked.BakedModelCover;
import net.minecraft.client.renderer.block.model.IBakedModel;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.client.renderer.vertex.VertexFormat;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.IModel;
import net.minecraftforge.common.model.IModelState;
import java.util.function.Function;
public class ModelCover implements IModel {
private boolean hollow;
public ModelCover(boolean hollow) {
this.hollow = hollow;
}
@Override
public IBakedModel bake(IModelState state, VertexFormat format, Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
return new BakedModelCover(null, hollow);
}
}

215
src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCableCover.java
View File

@@ -1,6 +1,7 @@
package com.raoulvdberge.refinedstorage.render.model.baked;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.CoverManager;
import com.raoulvdberge.refinedstorage.block.BlockCable;
import com.raoulvdberge.refinedstorage.render.CubeBuilder;
@@ -8,7 +9,6 @@ import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.block.model.*;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockRenderLayer;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.client.ForgeHooksClient;
@@ -37,29 +37,37 @@ public class BakedModelCableCover implements IBakedModel {
if (state != null) {
IExtendedBlockState s = (IExtendedBlockState) state;
boolean hasUp = CoverManager.getBlockState(s.getValue(BlockCable.COVER_UP)) != null;
boolean hasDown = CoverManager.getBlockState(s.getValue(BlockCable.COVER_DOWN)) != null;
boolean hasUp = s.getValue(BlockCable.COVER_UP) != null;
boolean hasDown = s.getValue(BlockCable.COVER_DOWN) != null;
boolean hasEast = CoverManager.getBlockState(s.getValue(BlockCable.COVER_EAST)) != null;
boolean hasWest = CoverManager.getBlockState(s.getValue(BlockCable.COVER_WEST)) != null;
boolean hasEast = s.getValue(BlockCable.COVER_EAST) != null;
boolean hasWest = s.getValue(BlockCable.COVER_WEST) != null;
addCover(quads, s.getValue(BlockCable.COVER_NORTH), EnumFacing.NORTH, side, rand, hasUp, hasDown, hasEast, hasWest);
addCover(quads, s.getValue(BlockCable.COVER_SOUTH), EnumFacing.SOUTH, side, rand, hasUp, hasDown, hasEast, hasWest);
addCover(quads, s.getValue(BlockCable.COVER_EAST), EnumFacing.EAST, side, rand, hasUp, hasDown, hasEast, hasWest);
addCover(quads, s.getValue(BlockCable.COVER_WEST), EnumFacing.WEST, side, rand, hasUp, hasDown, hasEast, hasWest);
addCover(quads, s.getValue(BlockCable.COVER_DOWN), EnumFacing.DOWN, side, rand, hasUp, hasDown, hasEast, hasWest);
addCover(quads, s.getValue(BlockCable.COVER_UP), EnumFacing.UP, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_NORTH), EnumFacing.NORTH, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_SOUTH), EnumFacing.SOUTH, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_EAST), EnumFacing.EAST, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_WEST), EnumFacing.WEST, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_DOWN), EnumFacing.DOWN, side, rand, hasUp, hasDown, hasEast, hasWest);
addCoverOrHollow(quads, s.getValue(BlockCable.COVER_UP), EnumFacing.UP, side, rand, hasUp, hasDown, hasEast, hasWest);
}
return quads;
}
protected static void addCover(List<BakedQuad> quads, @Nullable ItemStack coverStack, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
if (coverStack == null || coverStack.isEmpty()) {
protected static void addCoverOrHollow(List<BakedQuad> quads, @Nullable Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
if (cover == null) {
return;
}
IBlockState coverState = CoverManager.getBlockState(coverStack);
if (cover.isHollow()) {
addHollowCover(quads, cover, coverSide, side, rand, hasUp, hasDown, hasEast, hasWest);
} else {
addCover(quads, cover, coverSide, side, rand, hasUp, hasDown, hasEast, hasWest);
}
}
private static void addCover(List<BakedQuad> quads, Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
IBlockState coverState = CoverManager.getBlockState(cover.getStack());
if (coverState == null) {
return;
@@ -69,17 +77,20 @@ public class BakedModelCableCover implements IBakedModel {
TextureAtlasSprite sprite = getSprite(coverModel, coverState, side, rand);
ModelRotation modelRotation = ModelRotation.X0_Y0;
ModelRotation rotation = ModelRotation.X0_Y0;
int xStart = 0;
int xEnd = 16;
int xTexStart = 0;
int xTexEnd = 16;
int xTexBackStart = 0;
int xTexBackEnd = 16;
int yStart = 0;
int yEnd = 16;
int yTexStart = 0;
int yTexEnd = 16;
@@ -96,7 +107,7 @@ public class BakedModelCableCover implements IBakedModel {
xTexBackEnd = 14;
}
} else if (coverSide == EnumFacing.SOUTH) {
modelRotation = ModelRotation.X0_Y180;
rotation = ModelRotation.X0_Y180;
if (hasWest) {
xEnd = 14;
@@ -110,16 +121,16 @@ public class BakedModelCableCover implements IBakedModel {
xTexBackStart = 2;
}
} else if (coverSide == EnumFacing.EAST) {
modelRotation = ModelRotation.X0_Y90;
rotation = ModelRotation.X0_Y90;
} else if (coverSide == EnumFacing.WEST) {
modelRotation = ModelRotation.X0_Y270;
rotation = ModelRotation.X0_Y270;
} else if (coverSide == EnumFacing.DOWN) {
modelRotation = ModelRotation.X90_Y0;
rotation = ModelRotation.X90_Y0;
} else if (coverSide == EnumFacing.UP) {
modelRotation = ModelRotation.X270_Y0;
rotation = ModelRotation.X270_Y0;
}
if (coverSide.getAxis() == EnumFacing.Axis.X || coverSide.getAxis() == EnumFacing.Axis.Z) {
if (coverSide.getAxis() != EnumFacing.Axis.Y) {
if (hasDown) {
yStart = 2;
yTexEnd = 14;
@@ -140,14 +151,168 @@ public class BakedModelCableCover implements IBakedModel {
.face(EnumFacing.UP, 0, 16, 0, 2, sprite)
.face(EnumFacing.DOWN, 0, 16, 14, 16, sprite)
.face(EnumFacing.EAST, 14, 16, 0, 16, sprite)
.face(EnumFacing.WEST, 0, 2, 0, 16, sprite)
.face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
.face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)
.rotate(modelRotation)
.rotate(rotation)
.bake()
);
addHolder(quads, rotation);
}
private static void addHollowCover(List<BakedQuad> quads, Cover cover, EnumFacing coverSide, EnumFacing side, long rand, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest) {
IBlockState coverState = CoverManager.getBlockState(cover.getStack());
if (coverState == null) {
return;
}
IBakedModel coverModel = Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState(coverState);
TextureAtlasSprite sprite = getSprite(coverModel, coverState, side, rand);
ModelRotation rotation = ModelRotation.X0_Y0;
int xLeftStart = 13;
int xLeftEnd = 16;
int xLeftTexStart = 0;
int xLeftTexEnd = 3;
int xLeftTexBackStart = 13;
int xLeftTexBackEnd = 16;
int xRightStart = 0;
int xRightEnd = 3;
int xRightTexStart = 13;
int xRightTexEnd = 16;
int xRightTexBackStart = 0;
int xRightTexBackEnd = 3;
int yStart = 0;
int yEnd = 16;
int yTexStart = 0;
int yTexEnd = 16;
if (coverSide == EnumFacing.NORTH) {
if (hasEast) {
xLeftEnd = 14;
xLeftTexStart = 2;
xLeftTexBackEnd = 14;
}
if (hasWest) {
xRightStart = 2;
xRightTexEnd = 14;
xRightTexBackStart = 2;
}
} else if (coverSide == EnumFacing.SOUTH) {
rotation = ModelRotation.X0_Y180;
if (hasWest) {
xLeftEnd = 14;
xLeftTexStart = 2;
xLeftTexBackEnd = 14;
}
if (hasEast) {
xRightStart = 2;
xRightTexEnd = 14;
xRightTexBackStart = 2;
}
} else if (coverSide == EnumFacing.EAST) {
rotation = ModelRotation.X0_Y90;
} else if (coverSide == EnumFacing.WEST) {
rotation = ModelRotation.X0_Y270;
} else if (coverSide == EnumFacing.DOWN) {
rotation = ModelRotation.X90_Y0;
} else if (coverSide == EnumFacing.UP) {
rotation = ModelRotation.X270_Y0;
}
if (coverSide.getAxis() != EnumFacing.Axis.Y) {
if (hasDown) {
yStart = 2;
yTexEnd = 14;
}
if (hasUp) {
yEnd = 14;
yTexStart = 2;
}
}
quads.addAll(new CubeBuilder()
.from(xLeftStart, yStart, 0)
.to(xLeftEnd, yEnd, 2)
.face(EnumFacing.NORTH, xLeftTexStart, xLeftTexEnd, yTexStart, yTexEnd, sprite)
.face(EnumFacing.SOUTH, xLeftTexBackStart, xLeftTexBackEnd, yTexStart, yTexEnd, sprite)
.face(EnumFacing.UP, 13, 16, 0, 2, sprite)
.face(EnumFacing.DOWN, 13, 16, 14, 16, sprite)
.face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
.face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)
.rotate(rotation)
.bake()
);
quads.addAll(new CubeBuilder()
.from(xRightStart, yStart, 0)
.to(xRightEnd, yEnd, 2)
.face(EnumFacing.NORTH, xRightTexStart, xRightTexEnd, yTexStart, yTexEnd, sprite)
.face(EnumFacing.SOUTH, xRightTexBackStart, xRightTexBackEnd, yTexStart, yTexEnd, sprite)
.face(EnumFacing.UP, 0, 3, 0, 2, sprite)
.face(EnumFacing.DOWN, 0, 3, 14, 16, sprite)
.face(EnumFacing.EAST, 14, 16, yTexStart, yTexEnd, sprite)
.face(EnumFacing.WEST, 0, 2, yTexStart, yTexEnd, sprite)
.rotate(rotation)
.bake()
);
quads.addAll(new CubeBuilder()
.from(3, yStart, 0)
.to(13, 3, 2)
.face(EnumFacing.NORTH, 3, 13, 13, yTexEnd, sprite)
.face(EnumFacing.SOUTH, 3, 13, 13, yTexEnd, sprite)
.face(EnumFacing.UP, 3, 13, 0, 2, sprite)
.face(EnumFacing.DOWN, 3, 13, 14, 16, sprite)
.rotate(rotation)
.bake()
);
quads.addAll(new CubeBuilder()
.from(3, 13, 0)
.to(13, yEnd, 2)
.face(EnumFacing.NORTH, 3, 13, yTexStart, 3, sprite)
.face(EnumFacing.SOUTH, 3, 13, yTexStart, 3, sprite)
.face(EnumFacing.UP, 3, 13, 0, 2, sprite)
.face(EnumFacing.DOWN, 3, 13, 14, 16, sprite)
.rotate(rotation)
.bake()
);
}
private static void addHolder(List<BakedQuad> quads, ModelRotation rotation) {
if (GREY_SPRITE == null) {
GREY_SPRITE = Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(RS.ID + ":blocks/generic_grey");
}
@@ -163,7 +328,7 @@ public class BakedModelCableCover implements IBakedModel {
.face(EnumFacing.UP, 0, 0, 4, 2, GREY_SPRITE)
.face(EnumFacing.DOWN, 0, 0, 4, 2, GREY_SPRITE)
.rotate(modelRotation)
.rotate(rotation)
.setUvLocked(false)

68
src/main/java/com/raoulvdberge/refinedstorage/render/model/baked/BakedModelCover.java
View File

@@ -3,17 +3,20 @@ package com.raoulvdberge.refinedstorage.render.model.baked;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.raoulvdberge.refinedstorage.apiimpl.network.node.cover.Cover;
import com.raoulvdberge.refinedstorage.item.ItemCover;
import com.raoulvdberge.refinedstorage.util.RenderUtils;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.renderer.block.model.BakedQuad;
import net.minecraft.client.renderer.block.model.IBakedModel;
import net.minecraft.client.renderer.block.model.ItemCameraTransforms;
import net.minecraft.client.renderer.block.model.ItemOverrideList;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import net.minecraftforge.client.ForgeHooksClient;
import net.minecraftforge.common.model.TRSRTransformation;
import org.apache.commons.lang3.tuple.Pair;
import javax.annotation.Nullable;
@@ -25,16 +28,16 @@ import java.util.Objects;
public class BakedModelCover extends BakedModelCableCover {
private class CacheKey {
private IBakedModel base;
private IBlockState state;
private ItemStack stack;
private EnumFacing side;
private boolean hollow;
CacheKey(IBakedModel base, IBlockState state, ItemStack stack, EnumFacing side) {
this.base = base;
CacheKey(IBlockState state, ItemStack stack, EnumFacing side, boolean hollow) {
this.state = state;
this.stack = stack;
this.side = side;
this.hollow = hollow;
}
@Override
@@ -49,7 +52,7 @@ public class BakedModelCover extends BakedModelCableCover {
BakedModelCover.CacheKey cacheKey = (BakedModelCover.CacheKey) o;
return cacheKey.stack.getItem() == stack.getItem() && cacheKey.stack.getItemDamage() == stack.getItemDamage() && cacheKey.side == side && Objects.equals(cacheKey.state, state);
return cacheKey.hollow == hollow && cacheKey.stack.getItem() == stack.getItem() && cacheKey.stack.getItemDamage() == stack.getItemDamage() && cacheKey.side == side && Objects.equals(cacheKey.state, state);
}
@Override
@@ -58,6 +61,7 @@ public class BakedModelCover extends BakedModelCableCover {
result = 31 * result + stack.getItemDamage();
result = 31 * result + (side != null ? side.hashCode() : 0);
result = 31 * result + (state != null ? state.hashCode() : 0);
result = 31 * result + Boolean.hashCode(hollow);
return result;
}
}
@@ -65,9 +69,9 @@ public class BakedModelCover extends BakedModelCableCover {
private static final LoadingCache<CacheKey, List<BakedQuad>> CACHE = CacheBuilder.newBuilder().build(new CacheLoader<CacheKey, List<BakedQuad>>() {
@Override
public List<BakedQuad> load(CacheKey key) {
List<BakedQuad> quads = new ArrayList<>(key.base.getQuads(key.state, key.side, 0));
List<BakedQuad> quads = new ArrayList<>();
addCover(quads, key.stack, EnumFacing.NORTH, key.side, 0, false, false, false, false);
addCoverOrHollow(quads, new Cover(key.stack, key.hollow), EnumFacing.NORTH, key.side, 0, false, false, false, false);
return quads;
}
@@ -75,13 +79,13 @@ public class BakedModelCover extends BakedModelCableCover {
@Nullable
private ItemStack stack;
private IBakedModel base;
private boolean hollow;
public BakedModelCover(IBakedModel base, @Nullable ItemStack stack) {
super(base);
public BakedModelCover(@Nullable ItemStack stack, boolean hollow) {
super(null);
this.base = base;
this.stack = stack;
this.hollow = hollow;
}
@Override
@@ -90,7 +94,7 @@ public class BakedModelCover extends BakedModelCableCover {
return Collections.emptyList();
}
CacheKey key = new CacheKey(base, state, ItemCover.getItem(stack), side);
CacheKey key = new CacheKey(state, ItemCover.getItem(stack), side, hollow);
return CACHE.getUnchecked(key);
}
@@ -98,22 +102,52 @@ public class BakedModelCover extends BakedModelCableCover {
@Override
public ItemOverrideList getOverrides() {
if (stack != null) {
return base.getOverrides();
return ItemOverrideList.NONE;
}
return new ItemOverrideList(Collections.emptyList()) {
@Override
public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, @Nullable World world, @Nullable EntityLivingBase entity) {
return new BakedModelCover(base, stack);
return new BakedModelCover(stack, hollow);
}
};
}
@Override
public Pair<? extends IBakedModel, Matrix4f> handlePerspective(ItemCameraTransforms.TransformType cameraTransformType) {
Pair<? extends IBakedModel, Matrix4f> matrix = base.handlePerspective(cameraTransformType);
Pair<? extends IBakedModel, Matrix4f> bakedModel = ForgeHooksClient.handlePerspective(this, cameraTransformType);
TRSRTransformation transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType);
return Pair.of(bakedModel.getKey(), matrix.getRight());
return Pair.of(this, transform == null ? RenderUtils.EMPTY_MATRIX_TRANSFORM : transform.getMatrix());
}
@Override
public boolean isAmbientOcclusion() {
return true;
}
@Override
public boolean isGui3d() {
return true;
}
@Override
public boolean isBuiltInRenderer() {
return false;
}
@Override
public TextureAtlasSprite getParticleTexture() {
return null;
}
@Override
public boolean isAmbientOcclusion(IBlockState state) {
return true;
}
@Override
@SuppressWarnings("deprecation")
public ItemCameraTransforms getItemCameraTransforms() {
return ItemCameraTransforms.DEFAULT;
}
}

25
src/main/java/com/raoulvdberge/refinedstorage/render/model/loader/CustomModelLoaderCover.java Normal file
View File

@@ -0,0 +1,25 @@
package com.raoulvdberge.refinedstorage.render.model.loader;
import com.raoulvdberge.refinedstorage.RS;
import com.raoulvdberge.refinedstorage.render.model.ModelCover;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.ICustomModelLoader;
import net.minecraftforge.client.model.IModel;
public class CustomModelLoaderCover implements ICustomModelLoader {
@Override
public boolean accepts(ResourceLocation modelLocation) {
return modelLocation.getResourceDomain().equals(RS.ID) && (modelLocation.getResourcePath().equals("cover") || modelLocation.getResourcePath().equals("hollow_cover"));
}
@Override
public IModel loadModel(ResourceLocation modelLocation) {
return new ModelCover(modelLocation.getResourcePath().equals("hollow_cover"));
}
@Override
public void onResourceManagerReload(IResourceManager resourceManager) {
// NO OP
}
}

3
src/main/resources/assets/refinedstorage/blockstates/cover.json
View File

@@ -2,8 +2,7 @@
"forge_marker": 1,
"defaults": {
"textures": {
"cable": "refinedstorage:blocks/cable",
"line": "refinedstorage:blocks/generic_grey"
"cable": "refinedstorage:blocks/cable"
},
"model": "refinedstorage:cable_core",
"uvlock": true

18
src/main/resources/assets/refinedstorage/blockstates/hollow_cover.json Normal file
View File

@@ -0,0 +1,18 @@
{
"forge_marker": 1,
"defaults": {
"textures": {
"cable": "refinedstorage:blocks/cable"
},
"model": "refinedstorage:cable_core",
"uvlock": true
},
"variants": {
"inventory": [
{
"model": "refinedstorage:cable_core",
"transform": "forge:default-block"
}
]
}
}

1
src/main/resources/assets/refinedstorage/lang/en_us.lang
View File

@@ -292,6 +292,7 @@ item.refinedstorage:security_card.name=Security Card
item.refinedstorage:security_card.owner=Bound to: %s
item.refinedstorage:cutting_tool.name=Cutting Tool
item.refinedstorage:cover.name=Cover
item.refinedstorage:hollow_cover.name=Hollow Cover
commands.refinedstorage.createdisk.usage=/createdisk <player> <item> <metadata> <id>
commands.refinedstorage.createdisk.error.notADisk=The given disk item is not a disk.