Merge pull request #2881 from Buuz135/mc1.16

Ported covers from 1.12

src/main/java/com/refinedmods/refinedstorage/RSItems.java

@@ -43,6 +43,8 @@ public final class RSItems {
     public static final RegistryObject<WirelessCraftingMonitorItem> WIRELESS_CRAFTING_MONITOR;
     public static final RegistryObject<WirelessCraftingMonitorItem> CREATIVE_WIRELESS_CRAFTING_MONITOR;
     public static final RegistryObject<BlockItem> MACHINE_CASING;
+    public static final RegistryObject<CoverItem> COVER;
+    public static final RegistryObject<CoverItem> HOLLOW_COVER;
 
     public static final Map<ProcessorItem.Type, RegistryObject<ProcessorItem>> PROCESSORS = new EnumMap<>(ProcessorItem.Type.class);
 
@@ -121,6 +123,8 @@ public final class RSItems {
 
         registerBlockItemFor(RSBlocks.QUARTZ_ENRICHED_IRON);
         MACHINE_CASING = registerBlockItemFor(RSBlocks.MACHINE_CASING);
+        COVER = ITEMS.register("cover", CoverItem::new);
+        HOLLOW_COVER = ITEMS.register("hollow_cover", HollowCoverItem::new);
         registerBlockItemFor(RSBlocks.CABLE);
         registerBlockItemFor(RSBlocks.DISK_DRIVE);
 

src/main/java/com/refinedmods/refinedstorage/api/network/node/ICoverable.java

@@ -0,0 +1,9 @@
+package com.refinedmods.refinedstorage.api.network.node;
+
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+
+public interface ICoverable {
+
+    CoverManager getCoverManager();
+
+}

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/CableNetworkNode.java

@@ -1,15 +1,22 @@
 package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
 
-public class CableNetworkNode extends NetworkNode {
+public class CableNetworkNode extends NetworkNode implements ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "cable");
 
+    private final CoverManager coverManager;
+
     public CableNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -21,4 +28,23 @@ public class CableNetworkNode extends NetworkNode {
     public ResourceLocation getId() {
         return ID;
     }
+
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
+
+    @Override
+    public void read(CompoundNBT tag) {
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)){
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+        super.read(tag);
+    }
+
+    @Override
+    public CompoundNBT write(CompoundNBT tag) {
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
+        return super.write(tag);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ConstructorNetworkNode.java

@@ -1,8 +1,10 @@
 package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.api.util.Action;
 import com.refinedmods.refinedstorage.api.util.IComparer;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory;
 import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler;
 import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler;
@@ -43,7 +45,7 @@ import net.minecraftforge.items.IItemHandlerModifiable;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
-public class ConstructorNetworkNode extends NetworkNode implements IComparable, IType {
+public class ConstructorNetworkNode extends NetworkNode implements IComparable, IType, ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "constructor");
 
     private static final String NBT_COMPARE = "Compare";
@@ -64,8 +66,11 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable,
     private int type = IType.ITEMS;
     private boolean drop = false;
 
+    private final CoverManager coverManager;
+
     public ConstructorNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -174,6 +179,10 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable,
     public void read(CompoundNBT tag) {
         super.read(tag);
 
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)){
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+
         StackUtils.readItems(upgrades, 1, tag);
     }
 
@@ -186,6 +195,8 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable,
     public CompoundNBT write(CompoundNBT tag) {
         super.write(tag);
 
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
+
         StackUtils.writeItems(upgrades, 1, tag);
 
         return tag;
@@ -268,6 +279,11 @@ public class ConstructorNetworkNode extends NetworkNode implements IComparable,
         return fluidFilters;
     }
 
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
+
     private class NetworkFluidHandler implements IFluidHandler {
         private final FluidStack resource;
 

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/DestructorNetworkNode.java

@@ -1,8 +1,10 @@
 package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.api.util.Action;
 import com.refinedmods.refinedstorage.api.util.IComparer;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory;
 import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler;
 import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler;
@@ -47,7 +49,7 @@ import net.minecraftforge.items.IItemHandlerModifiable;
 import java.util.ArrayList;
 import java.util.List;
 
-public class DestructorNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType {
+public class DestructorNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType, ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "destructor");
 
     private static final String NBT_COMPARE = "Compare";
@@ -71,8 +73,11 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I
     private boolean pickupItem = false;
     private ItemStack tool = createTool();
 
+    private final CoverManager coverManager;
+
     public DestructorNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -250,6 +255,10 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I
     public void read(CompoundNBT tag) {
         super.read(tag);
 
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)){
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+
         StackUtils.readItems(upgrades, 1, tag);
     }
 
@@ -262,6 +271,8 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I
     public CompoundNBT write(CompoundNBT tag) {
         super.write(tag);
 
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
+
         StackUtils.writeItems(upgrades, 1, tag);
 
         return tag;
@@ -348,4 +359,9 @@ public class DestructorNetworkNode extends NetworkNode implements IComparable, I
     public void setPickupItem(boolean pickupItem) {
         this.pickupItem = pickupItem;
     }
+
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExporterNetworkNode.java

@@ -1,9 +1,11 @@
 package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.api.util.Action;
 import com.refinedmods.refinedstorage.api.util.IComparer;
 import com.refinedmods.refinedstorage.apiimpl.API;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory;
 import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler;
 import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler;
@@ -27,7 +29,7 @@ import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 import net.minecraftforge.items.ItemHandlerHelper;
 
-public class ExporterNetworkNode extends NetworkNode implements IComparable, IType {
+public class ExporterNetworkNode extends NetworkNode implements IComparable, IType, ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "exporter");
 
     private static final String NBT_COMPARE = "Compare";
@@ -72,8 +74,11 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
 
     private int filterSlot;
 
+    private final CoverManager coverManager;
+
     public ExporterNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -245,8 +250,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
     public CompoundNBT write(CompoundNBT tag) {
         super.write(tag);
 
-        StackUtils.writeItems(upgrades, 1, tag);
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
 
+        StackUtils.writeItems(upgrades, 1, tag);
         return tag;
     }
 
@@ -268,6 +274,10 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
     public void read(CompoundNBT tag) {
         super.read(tag);
 
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)){
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+
         StackUtils.readItems(upgrades, 1, tag);
     }
 
@@ -320,4 +330,9 @@ public class ExporterNetworkNode extends NetworkNode implements IComparable, ITy
     public FluidInventory getFluidFilters() {
         return fluidFilters;
     }
+
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ExternalStorageNetworkNode.java

@@ -2,6 +2,7 @@ package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
 import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.api.storage.AccessType;
 import com.refinedmods.refinedstorage.api.storage.IStorage;
 import com.refinedmods.refinedstorage.api.storage.IStorageProvider;
@@ -12,6 +13,7 @@ import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStora
 import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStorageProvider;
 import com.refinedmods.refinedstorage.api.util.IComparer;
 import com.refinedmods.refinedstorage.apiimpl.API;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.apiimpl.storage.cache.FluidStorageCache;
 import com.refinedmods.refinedstorage.apiimpl.storage.cache.ItemStorageCache;
 import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory;
@@ -39,7 +41,7 @@ import org.apache.logging.log4j.Logger;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
-public class ExternalStorageNetworkNode extends NetworkNode implements IStorageProvider, IStorageScreen, IComparable, IWhitelistBlacklist, IPrioritizable, IType, IAccessType, IExternalStorageContext {
+public class ExternalStorageNetworkNode extends NetworkNode implements IStorageProvider, IStorageScreen, IComparable, IWhitelistBlacklist, IPrioritizable, IType, IAccessType, IExternalStorageContext, ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "external_storage");
 
     private static final Logger LOGGER = LogManager.getLogger(ExternalStorageNetworkNode.class);
@@ -63,8 +65,11 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP
     private final List<IExternalStorage<ItemStack>> itemStorages = new CopyOnWriteArrayList<>();
     private final List<IExternalStorage<FluidStack>> fluidStorages = new CopyOnWriteArrayList<>();
 
+    private final CoverManager coverManager;
+
     public ExternalStorageNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -319,4 +324,29 @@ public class ExternalStorageNetworkNode extends NetworkNode implements IStorageP
     public List<IExternalStorage<FluidStack>> getFluidStorages() {
         return fluidStorages;
     }
+
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
+
+    @Override
+    public void read(CompoundNBT tag) {
+        super.read(tag);
+
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)) {
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+    }
+
+
+
+    @Override
+    public CompoundNBT write(CompoundNBT tag) {
+        super.write(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
+
+        return tag;
+    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/ImporterNetworkNode.java

@@ -1,8 +1,10 @@
 package com.refinedmods.refinedstorage.apiimpl.network.node;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.api.util.Action;
 import com.refinedmods.refinedstorage.api.util.IComparer;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.inventory.fluid.FluidInventory;
 import com.refinedmods.refinedstorage.inventory.item.BaseItemHandler;
 import com.refinedmods.refinedstorage.inventory.item.UpgradeItemHandler;
@@ -28,7 +30,7 @@ import net.minecraftforge.fluids.capability.IFluidHandler;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
-public class ImporterNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType {
+public class ImporterNetworkNode extends NetworkNode implements IComparable, IWhitelistBlacklist, IType, ICoverable {
     public static final ResourceLocation ID = new ResourceLocation(RS.ID, "importer");
 
     private static final String NBT_COMPARE = "Compare";
@@ -47,8 +49,11 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh
 
     private int currentSlot;
 
+    private final CoverManager coverManager;
+
     public ImporterNetworkNode(World world, BlockPos pos) {
         super(world, pos);
+        this.coverManager = new CoverManager(this);
     }
 
     @Override
@@ -149,6 +154,10 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh
     public void read(CompoundNBT tag) {
         super.read(tag);
 
+        if (tag.contains(CoverManager.NBT_COVER_MANAGER)) {
+            this.coverManager.readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+        }
+
         StackUtils.readItems(upgrades, 1, tag);
     }
 
@@ -161,6 +170,8 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh
     public CompoundNBT write(CompoundNBT tag) {
         super.write(tag);
 
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.coverManager.writeToNbt());
+
         StackUtils.writeItems(upgrades, 1, tag);
 
         return tag;
@@ -234,4 +245,9 @@ public class ImporterNetworkNode extends NetworkNode implements IComparable, IWh
     public FluidInventory getFluidFilters() {
         return fluidFilters;
     }
+
+    @Override
+    public CoverManager getCoverManager() {
+        return coverManager;
+    }
 }

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/Cover.java

@@ -0,0 +1,22 @@
+package com.refinedmods.refinedstorage.apiimpl.network.node.cover;
+
+import net.minecraft.item.ItemStack;
+
+public class Cover {
+
+    private ItemStack stack;
+    private CoverType type;
+
+    public Cover(ItemStack stack, CoverType type) {
+        this.stack = stack;
+        this.type = type;
+    }
+
+    public ItemStack getStack() {
+        return stack;
+    }
+
+    public CoverType getType() {
+        return type;
+    }
+}

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverManager.java

@@ -0,0 +1,193 @@
+package com.refinedmods.refinedstorage.apiimpl.network.node.cover;
+
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+import com.refinedmods.refinedstorage.api.util.Action;
+import com.refinedmods.refinedstorage.apiimpl.API;
+import com.refinedmods.refinedstorage.apiimpl.network.node.CableNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.NetworkNode;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import net.minecraft.block.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraftforge.client.model.data.ModelProperty;
+import net.minecraftforge.items.IItemHandlerModifiable;
+import net.minecraftforge.items.ItemStackHandler;
+
+import javax.annotation.Nullable;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CoverManager {
+
+    public static String NBT_COVER_MANAGER = "Cover";
+
+    public static final ModelProperty<CoverManager> PROPERTY = new ModelProperty<>();
+
+    private static final String NBT_DIRECTION = "Direction";
+    private static final String NBT_ITEM = "Item";
+    private static final String NBT_TYPE = "Type";
+
+    private Map<Direction, Cover> covers = new HashMap<>();
+    private NetworkNode node;
+
+    public CoverManager(NetworkNode node) {
+        this.node = node;
+    }
+
+    @Nullable
+    public Cover getCover(Direction facing) {
+        return covers.get(facing);
+    }
+
+    public boolean hasCover(Direction facing) {
+        return covers.containsKey(facing);
+    }
+
+    public boolean setCover(Direction facing, @Nullable Cover cover) {
+        if (cover == null || (isValidCover(cover.getStack()) && !hasCover(facing))) {
+            if (cover != null) {
+                if (!(node instanceof CableNetworkNode) && facing == node.getDirection() && cover.getType() != CoverType.HOLLOW) {
+                    return false;
+                }
+            }
+
+            if (cover == null) {
+                covers.remove(facing);
+            } else {
+                covers.put(facing, cover);
+            }
+
+            node.markDirty();
+
+            if (node.getNetwork() != null) {
+                node.getNetwork().getNodeGraph().invalidate(Action.PERFORM, node.getNetwork().getWorld(), node.getNetwork().getPosition());
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    @Nullable
+    public Cover removeCover(Direction direction){
+        if (hasCover(direction)){
+            Cover cover = covers.remove(direction);
+
+            node.markDirty();
+
+            if (node.getNetwork() != null) {
+                node.getNetwork().getNodeGraph().invalidate(Action.PERFORM, node.getNetwork().getWorld(), node.getNetwork().getPosition());
+            }
+
+            return cover;
+        }
+        return null;
+    }
+
+    public void readFromNbt(CompoundNBT nbt) {
+        covers.clear();
+        for (String s : nbt.keySet()) {
+            CompoundNBT tag = nbt.getCompound(s);
+            if (tag.contains(NBT_DIRECTION) && tag.contains(NBT_ITEM)) {
+                Direction direction = Direction.byIndex(tag.getInt(NBT_DIRECTION));
+                ItemStack item = ItemStack.read(tag.getCompound(NBT_ITEM));
+                int type = tag.contains(NBT_TYPE) ? tag.getInt(NBT_TYPE) : 0;
+
+                if (type >= CoverType.values().length) {
+                    type = 0;
+                }
+
+                if (isValidCover(item)) {
+                    covers.put(direction, new Cover(item, CoverType.values()[type]));
+                }
+            }
+        }
+    }
+
+    public CompoundNBT writeToNbt() {
+        CompoundNBT list = new CompoundNBT();
+
+        for (Map.Entry<Direction, Cover> entry : covers.entrySet()) {
+            CompoundNBT tag = new CompoundNBT();
+
+            tag.putInt(NBT_DIRECTION, entry.getKey().ordinal());
+            tag.put(NBT_ITEM, entry.getValue().getStack().serializeNBT());
+            tag.putInt(NBT_TYPE, entry.getValue().getType().ordinal());
+
+            list.put(entry.getKey().ordinal() + "",tag);
+        }
+        return list;
+    }
+
+    public IItemHandlerModifiable getAsInventory() {
+        ItemStackHandler handler = new ItemStackHandler(covers.size());
+
+        int i = 0;
+
+        for (Map.Entry<Direction, Cover> entry : covers.entrySet()) {
+            ItemStack cover = entry.getValue().getType().createStack();
+
+            CoverItem.setItem(cover, entry.getValue().getStack());
+
+            handler.setStackInSlot(i++, cover);
+        }
+
+        return handler;
+    }
+
+    @SuppressWarnings("deprecation")
+    public static boolean isValidCover(ItemStack item) {
+        if (item.isEmpty()) {
+            return false;
+        }
+
+        Block block = getBlock(item);
+
+        BlockState state = getBlockState(item);
+
+        return block != null && state != null && isModelSupported(state) && !block.ticksRandomly(state)
+                && !block.hasTileEntity(state) && !state.isTransparent(); //Changed from 1.12: to use 1.16 methods
+    }
+
+    private static boolean isModelSupported(BlockState state) {
+        if (state.getRenderType() != BlockRenderType.MODEL) {
+            return false;
+        }
+
+        return state.isSolid();
+    }
+
+    @Nullable
+    public static Block getBlock(ItemStack item) {
+        if (item.isEmpty()) {
+            return null;
+        }
+
+        Block block = Block.getBlockFromItem(item.getItem());
+
+        if (block == Blocks.AIR) {
+            return null;
+        }
+
+        return block;
+    }
+
+    @Nullable
+    @SuppressWarnings("deprecation")
+    public static BlockState getBlockState(ItemStack item) {
+        Block block = getBlock(item);
+
+        if (block == null) {
+            return null;
+        }
+
+        return block.getDefaultState();
+    }
+    
+}

src/main/java/com/refinedmods/refinedstorage/apiimpl/network/node/cover/CoverType.java

@@ -0,0 +1,14 @@
+package com.refinedmods.refinedstorage.apiimpl.network.node.cover;
+
+import com.refinedmods.refinedstorage.RSItems;
+import net.minecraft.block.Blocks;
+import net.minecraft.item.ItemStack;
+
+public enum CoverType {
+    NORMAL,
+    HOLLOW;
+
+    public ItemStack createStack() {
+       return new ItemStack(this == NORMAL ? RSItems.COVER.get() : RSItems.HOLLOW_COVER.get() );
+    }
+}

src/main/java/com/refinedmods/refinedstorage/block/CableBlock.java

@@ -1,8 +1,15 @@
 package com.refinedmods.refinedstorage.block;
 
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.api.network.node.INetworkNodeProxy;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.capability.NetworkNodeProxyCapability;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.CableTile;
+import com.refinedmods.refinedstorage.tile.NetworkNodeTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
@@ -75,7 +82,7 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable {
     @Override
     @SuppressWarnings("deprecation")
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, CableBlock::getCableShape);
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, CableBlock::getCableShape), world, pos);
     }
 
     protected static VoxelShape getCableShape(BlockState state) {
@@ -122,6 +129,12 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable {
         super.onDirectionChanged(world, pos, newDirection);
     }
 
+    @Override
+    public void neighborChanged(BlockState state, World world, BlockPos pos, Block blockIn, BlockPos fromPos, boolean isMoving) {
+        super.neighborChanged(state, world, pos, blockIn, fromPos, isMoving);
+        world.setBlockState(pos, getState(world.getBlockState(pos), world, pos));
+    }
+
     @Nullable
     @Override
     public BlockState getStateForPlacement(BlockItemUseContext ctx) {
@@ -155,7 +168,21 @@ public class CableBlock extends NetworkNodeBlock implements IWaterLoggable {
             return false;
         }
 
-        return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent();
+        return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction).isPresent()
+                && isSideNotCoveredOrHollow(tile, direction)
+                && isSideNotCoveredOrHollow(world.getTileEntity(pos.offset(direction)), direction.getOpposite());
+    }
+
+    private boolean isSideNotCoveredOrHollow(TileEntity tile, Direction direction){
+        if (tile == null){
+            return false;
+        }
+        return tile.getCapability(NetworkNodeProxyCapability.NETWORK_NODE_PROXY_CAPABILITY, direction)
+                .map(INetworkNodeProxy::getNode)
+                .map(iNetworkNode -> !(iNetworkNode instanceof ICoverable)
+                        || (!((ICoverable) iNetworkNode).getCoverManager().hasCover(direction)
+                        || ((ICoverable) iNetworkNode).getCoverManager().getCover(direction).getType() == CoverType.HOLLOW))
+                .orElse(false);
     }
 
     private BlockState getState(BlockState currentState, IWorld world, BlockPos pos) {

src/main/java/com/refinedmods/refinedstorage/block/ConstructorBlock.java

@@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block;
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.container.ConstructorContainer;
 import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.ConstructorTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import com.refinedmods.refinedstorage.util.CollisionUtils;
@@ -51,13 +52,13 @@ public class ConstructorBlock extends CableBlock {
 
     @Override
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, s -> {
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> {
             VoxelShape shape = getCableShape(s);
 
             shape = VoxelShapes.or(shape, getHeadShape(s));
 
             return shape;
-        });
+        }), world, pos);
     }
 
     private VoxelShape getHeadShape(BlockState state) {

src/main/java/com/refinedmods/refinedstorage/block/DestructorBlock.java

@@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block;
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.container.DestructorContainer;
 import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.DestructorTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import com.refinedmods.refinedstorage.util.CollisionUtils;
@@ -51,13 +52,13 @@ public class DestructorBlock extends CableBlock {
 
     @Override
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, s -> {
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> {
             VoxelShape shape = getCableShape(s);
 
             shape = VoxelShapes.or(shape, getHeadShape(s));
 
             return shape;
-        });
+        }), world, pos);
     }
 
     private VoxelShape getHeadShape(BlockState state) {

src/main/java/com/refinedmods/refinedstorage/block/ExporterBlock.java

@@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block;
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.container.ExporterContainer;
 import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.ExporterTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import com.refinedmods.refinedstorage.util.CollisionUtils;
@@ -68,15 +69,16 @@ public class ExporterBlock extends CableBlock {
 
     @Override
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, s -> {
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> {
             VoxelShape shape = getCableShape(s);
 
             shape = VoxelShapes.or(shape, getLineShape(s));
 
             return shape;
-        });
+        }), world, pos);
     }
 
+
     private VoxelShape getLineShape(BlockState state) {
         Direction direction = state.get(getDirection().getProperty());
 

src/main/java/com/refinedmods/refinedstorage/block/ExternalStorageBlock.java

@@ -6,6 +6,7 @@ import com.refinedmods.refinedstorage.apiimpl.network.node.ExternalStorageNetwor
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.container.ExternalStorageContainer;
 import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.ExternalStorageTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import com.refinedmods.refinedstorage.util.CollisionUtils;
@@ -49,13 +50,13 @@ public class ExternalStorageBlock extends CableBlock {
 
     @Override
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, s -> {
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> {
             VoxelShape shape = getCableShape(s);
 
             shape = VoxelShapes.or(shape, getHeadShape(s));
 
             return shape;
-        });
+        }), world, pos);
     }
 
     private VoxelShape getHeadShape(BlockState state) {

src/main/java/com/refinedmods/refinedstorage/block/ImporterBlock.java

@@ -3,6 +3,7 @@ package com.refinedmods.refinedstorage.block;
 import com.refinedmods.refinedstorage.block.shape.ShapeCache;
 import com.refinedmods.refinedstorage.container.ImporterContainer;
 import com.refinedmods.refinedstorage.container.factory.PositionalTileContainerProvider;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
 import com.refinedmods.refinedstorage.tile.ImporterTile;
 import com.refinedmods.refinedstorage.util.BlockUtils;
 import com.refinedmods.refinedstorage.util.CollisionUtils;
@@ -68,13 +69,13 @@ public class ImporterBlock extends CableBlock {
 
     @Override
     public VoxelShape getShape(BlockState state, IBlockReader world, BlockPos pos, ISelectionContext ctx) {
-        return ShapeCache.getOrCreate(state, s -> {
+        return ConstantsCable.addCoverVoxelShapes(ShapeCache.getOrCreate(state, s -> {
             VoxelShape shape = getCableShape(s);
 
             shape = VoxelShapes.or(shape, getLineShape(s));
 
             return shape;
-        });
+        }), world, pos);
     }
 
     private VoxelShape getLineShape(BlockState state) {

src/main/java/com/refinedmods/refinedstorage/config/ClientConfig.java

@@ -8,11 +8,12 @@ public class ClientConfig {
 
     private final Grid grid;
     private final CrafterManager crafterManager;
+    private final Cover cover;
 
     public ClientConfig() {
         grid = new Grid();
         crafterManager = new CrafterManager();
-
+        cover = new Cover();
         spec = builder.build();
     }
 
@@ -28,6 +29,10 @@ public class ClientConfig {
         return crafterManager;
     }
 
+    public Cover getCover() {
+        return cover;
+    }
+
     public class Grid {
         private final ForgeConfigSpec.IntValue maxRowsStretch;
         private final ForgeConfigSpec.BooleanValue detailedTooltip;
@@ -83,4 +88,19 @@ public class ClientConfig {
             return maxRowsStretch.get();
         }
     }
+
+    public class Cover{
+
+        private final ForgeConfigSpec.BooleanValue showAllCoversInJEI;
+
+        public Cover() {
+            builder.push("cover");
+            showAllCoversInJEI = builder.comment("When true all the possible covers will be added to JEI (Game restart required)").define("showAllCoversInJEI", true);
+            builder.pop();
+        }
+
+        public boolean showAllRecipesInJEI() {
+            return showAllCoversInJEI.get();
+        }
+    }
 }

src/main/java/com/refinedmods/refinedstorage/integration/jei/CoverCraftingCategoryExtension.java

@@ -0,0 +1,83 @@
+package com.refinedmods.refinedstorage.integration.jei;
+
+import com.refinedmods.refinedstorage.RSItems;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import com.refinedmods.refinedstorage.recipe.CoverRecipe;
+import mezz.jei.api.constants.VanillaTypes;
+import mezz.jei.api.gui.IRecipeLayout;
+import mezz.jei.api.ingredients.IIngredients;
+import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICraftingCategoryExtension;
+import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICustomCraftingCategoryExtension;
+import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.Tags;
+import net.minecraftforge.common.util.Size2i;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class CoverCraftingCategoryExtension implements ICustomCraftingCategoryExtension {
+
+    @Override
+    public void setIngredients(IIngredients ingredients) {
+        List<ItemStack> input = new ArrayList<>();
+        List<ItemStack> output = new ArrayList<>();
+        for (Block block : ForgeRegistries.BLOCKS.getValues()) {
+            Item item = Item.getItemFromBlock(block);
+            if (item == Items.AIR) {
+                continue;
+            }
+            NonNullList<ItemStack> subBlocks = NonNullList.create();
+            block.fillItemGroup(ItemGroup.SEARCH, subBlocks);
+            for (ItemStack subBlock : subBlocks) {
+                if (CoverManager.isValidCover(subBlock)) {
+                    input.add(subBlock);
+                    ItemStack stack = new ItemStack(RSItems.COVER.get());
+                    CoverItem.setItem(stack, subBlock);
+                    output.add(stack);
+                }
+            }
+        }
+        ingredients.setInputLists(VanillaTypes.ITEM, Arrays.asList(Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList()), input));
+        ingredients.setOutputs(VanillaTypes.ITEM, output);
+    }
+
+    @Nullable
+    @Override
+    public Size2i getSize() {
+        return new Size2i(2, 1);
+    }
+
+    @Nullable
+    @Override
+    public ResourceLocation getRegistryName() {
+        return CoverRecipe.SERIALIZER.getRegistryName();
+    }
+
+    @Override
+    public void setRecipe(IRecipeLayout recipeLayout, IIngredients ingredients) {
+        ItemStack stack = recipeLayout.getFocus(VanillaTypes.ITEM).getValue();
+        if (stack.getItem() instanceof CoverItem){
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList()));
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, CoverItem.getItem(stack));
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack);
+        } else {
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(4, Tags.Items.NUGGETS_IRON.getAllElements().stream().map(ItemStack::new).collect(Collectors.toList()));
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack);
+            ItemStack output = new ItemStack(RSItems.COVER.get());
+            CoverItem.setItem(output, stack);
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output);
+        }
+    }
+}

src/main/java/com/refinedmods/refinedstorage/integration/jei/HollowCoverCraftingCategoryExtension.java

@@ -0,0 +1,64 @@
+package com.refinedmods.refinedstorage.integration.jei;
+
+import com.refinedmods.refinedstorage.RSItems;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import com.refinedmods.refinedstorage.recipe.CoverRecipe;
+import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe;
+import mezz.jei.api.constants.VanillaTypes;
+import mezz.jei.api.gui.IRecipeLayout;
+import mezz.jei.api.ingredients.IIngredients;
+import mezz.jei.api.recipe.category.extensions.vanilla.crafting.ICustomCraftingCategoryExtension;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.common.Tags;
+import net.minecraftforge.common.util.Size2i;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class HollowCoverCraftingCategoryExtension implements ICustomCraftingCategoryExtension {
+
+    @Override
+    public void setIngredients(IIngredients ingredients) {
+        ingredients.setInput(VanillaTypes.ITEM, new ItemStack(RSItems.COVER.get()));
+        ingredients.setOutput(VanillaTypes.ITEM, new ItemStack(RSItems.HOLLOW_COVER.get()));
+    }
+
+    @Nullable
+    @Override
+    public Size2i getSize() {
+        return new Size2i(2, 1);
+    }
+
+    @Nullable
+    @Override
+    public ResourceLocation getRegistryName() {
+        return HollowCoverRecipe.SERIALIZER.getRegistryName();
+    }
+
+    @Override
+    public void setRecipe(IRecipeLayout recipeLayout, IIngredients ingredients) {
+        ItemStack stack = recipeLayout.getFocus(VanillaTypes.ITEM).getValue();
+        if (stack.getItem() == RSItems.COVER.get()){
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, stack);
+            ItemStack output = new ItemStack(RSItems.HOLLOW_COVER.get());
+            CoverItem.setItem(output, CoverItem.getItem(stack));
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, output);
+        } else {
+            ItemStack input = new ItemStack(RSItems.COVER.get());
+            CoverItem.setItem(input,  CoverItem.getItem(stack));
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(5, input);
+            recipeLayout.getIngredientsGroup(VanillaTypes.ITEM).set(0, stack);
+        }
+    }
+}

src/main/java/com/refinedmods/refinedstorage/integration/jei/RSJeiPlugin.java

@@ -1,14 +1,19 @@
 package com.refinedmods.refinedstorage.integration.jei;
 
 import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.RSItems;
+import com.refinedmods.refinedstorage.recipe.CoverRecipe;
+import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe;
 import com.refinedmods.refinedstorage.screen.BaseScreen;
 import mezz.jei.api.IModPlugin;
 import mezz.jei.api.JeiPlugin;
-import mezz.jei.api.registration.IGuiHandlerRegistration;
+import mezz.jei.api.constants.VanillaRecipeCategoryUid;
-import mezz.jei.api.registration.IRecipeTransferRegistration;
+import mezz.jei.api.registration.*;
 import mezz.jei.api.runtime.IJeiRuntime;
 import net.minecraft.util.ResourceLocation;
 
+import java.util.Collections;
+
 @JeiPlugin
 public class RSJeiPlugin implements IModPlugin {
     private static final ResourceLocation ID = new ResourceLocation(RS.ID, "plugin");
@@ -39,4 +44,15 @@ public class RSJeiPlugin implements IModPlugin {
     public static IJeiRuntime getRuntime() {
         return runtime;
     }
+
+    @Override
+    public void registerItemSubtypes(ISubtypeRegistration registration) {
+        registration.useNbtForSubtypes(RSItems.COVER.get(), RSItems.HOLLOW_COVER.get());
+    }
+
+    @Override
+    public void registerVanillaCategoryExtensions(IVanillaCategoryExtensionRegistration registration) {
+        registration.getCraftingCategory().addCategoryExtension(CoverRecipe.class, (cover) -> new CoverCraftingCategoryExtension());
+        registration.getCraftingCategory().addCategoryExtension(HollowCoverRecipe.class, (cover) -> new HollowCoverCraftingCategoryExtension());
+    }
 }

src/main/java/com/refinedmods/refinedstorage/item/CoverItem.java

@@ -0,0 +1,166 @@
+package com.refinedmods.refinedstorage.item;
+
+import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
+import com.refinedmods.refinedstorage.api.network.security.Permission;
+import com.refinedmods.refinedstorage.apiimpl.API;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
+import com.refinedmods.refinedstorage.tile.NetworkNodeTile;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.item.*;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TextComponent;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraftforge.client.model.ModelDataManager;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+
+public class CoverItem extends Item {
+
+    private static final String NBT_ITEM = "Item";
+
+    public static final ItemStack HIDDEN_COVER_ALTERNATIVE = new ItemStack(Blocks.STONE_BRICKS);
+
+
+    public CoverItem() {
+        super(new Item.Properties().group(RS.MAIN_GROUP));
+    }
+
+    public static void setItem(ItemStack cover, ItemStack item) {
+        if (!cover.hasTag()) {
+            cover.setTag(new CompoundNBT());
+        }
+        ItemStack result = item.copy();
+        result.setCount(1);
+        cover.getTag().put(NBT_ITEM, result.serializeNBT());
+    }
+
+    @Nonnull
+    public static ItemStack getItem(ItemStack cover) {
+        if (!cover.hasTag() || !cover.getTag().contains(NBT_ITEM)) {
+            return ItemStack.EMPTY;
+        }
+
+        return ItemStack.read(cover.getTag().getCompound(NBT_ITEM));
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip, ITooltipFlag flagIn) {
+        super.addInformation(stack, worldIn, tooltip, flagIn);
+        ItemStack item = getItem(stack);
+
+        if (!item.isEmpty()) {
+            tooltip.add(((TextComponent)item.getItem().getDisplayName(item)).mergeStyle(TextFormatting.GRAY));
+        }
+    }
+
+    @Override
+    public void fillItemGroup(ItemGroup group, NonNullList<ItemStack> items) {
+        if (this.isInGroup(group)) { //Changed from 1.12: to use 1.16 configs
+            if (!RS.CLIENT_CONFIG.getCover().showAllRecipesInJEI()) {
+                ItemStack stack = new ItemStack(this);
+
+                setItem(stack, HIDDEN_COVER_ALTERNATIVE);
+
+                items.add(stack);
+
+                return;
+            }
+            for (Block block : ForgeRegistries.BLOCKS.getValues()) {
+                Item item = Item.getItemFromBlock(block);
+
+                if (item == Items.AIR) {
+                    continue;
+                }
+
+                NonNullList<ItemStack> subBlocks = NonNullList.create();
+
+                block.fillItemGroup(ItemGroup.SEARCH, subBlocks);
+
+                for (ItemStack subBlock : subBlocks) {
+                    if (CoverManager.isValidCover(subBlock)) {
+                        ItemStack stack = new ItemStack(this);
+
+                        setItem(stack, subBlock);
+
+                        items.add(stack);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public ActionResultType onItemUse(ItemUseContext context) {
+        BlockPos pos = context.getPos();
+        Direction facing = context.getFace();
+        World world = context.getWorld();
+
+        ItemStack stack = context.getPlayer().getHeldItem(context.getHand());
+
+        TileEntity tile = world.getTileEntity(pos);
+
+        // Support placing on the bottom side without too much hassle.
+        if (!canPlaceOn(tile)) {
+            pos = pos.up();
+
+            facing = Direction.DOWN;
+
+            tile = world.getTileEntity(pos);
+        }
+
+        if (canPlaceOn(tile)) {
+            if (world.isRemote) {
+                ModelDataManager.requestModelDataRefresh(tile);
+                return ActionResultType.SUCCESS;
+            }
+
+            INetworkNode node = ((NetworkNodeTile<?>) tile).getNode();
+
+            if (node.getNetwork() != null && !node.getNetwork().getSecurityManager().hasPermission(Permission.BUILD, context.getPlayer())) {
+                WorldUtils.sendNoPermissionMessage(context.getPlayer());
+
+                return ActionResultType.FAIL;
+            }
+
+            if (((ICoverable) node).getCoverManager().setCover(facing, createCover(getItem(stack)))) {
+                context.getPlayer().getHeldItem(context.getHand()).shrink(1);
+
+                WorldUtils.updateBlock(world, pos);
+                API.instance().getNetworkNodeManager((ServerWorld) world).markForSaving();
+                return ActionResultType.SUCCESS;
+            }
+
+            return ActionResultType.FAIL;
+        }
+
+        return ActionResultType.PASS;
+    }
+
+
+    private boolean canPlaceOn(TileEntity tile) {
+        return tile instanceof NetworkNodeTile && ((NetworkNodeTile<?>) tile).getNode() instanceof ICoverable;
+    }
+
+    protected Cover createCover(ItemStack stack) {
+        return new Cover(stack, CoverType.NORMAL);
+    }
+
+}

src/main/java/com/refinedmods/refinedstorage/item/HollowCoverItem.java

@@ -0,0 +1,17 @@
+package com.refinedmods.refinedstorage.item;
+
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
+import net.minecraft.item.ItemStack;
+
+public class HollowCoverItem extends CoverItem{
+
+    public HollowCoverItem() {
+        super();
+    }
+
+    @Override
+    protected Cover createCover(ItemStack stack) {
+        return new Cover(stack, CoverType.HOLLOW);
+    }
+}

src/main/java/com/refinedmods/refinedstorage/item/WrenchItem.java

@@ -2,7 +2,11 @@ package com.refinedmods.refinedstorage.item;
 
 import com.refinedmods.refinedstorage.RS;
 import com.refinedmods.refinedstorage.api.network.INetwork;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.api.network.node.INetworkNode;
 import com.refinedmods.refinedstorage.api.network.security.Permission;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
 import com.refinedmods.refinedstorage.util.NetworkUtils;
 import com.refinedmods.refinedstorage.util.WorldUtils;
 import net.minecraft.block.BlockState;
@@ -11,6 +15,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.item.ItemUseContext;
 import net.minecraft.util.ActionResultType;
 import net.minecraft.util.Rotation;
+import net.minecraftforge.items.ItemHandlerHelper;
 
 public class WrenchItem extends Item {
     public WrenchItem() {
@@ -23,15 +28,27 @@ public class WrenchItem extends Item {
             return ActionResultType.CONSUME;
         }
 
-        INetwork network = NetworkUtils.getNetworkFromNode(NetworkUtils.getNodeFromTile(ctx.getWorld().getTileEntity(ctx.getPos())));
+        INetworkNode node = NetworkUtils.getNodeFromTile(ctx.getWorld().getTileEntity(ctx.getPos()));
+        INetwork network = NetworkUtils.getNetworkFromNode(node);
         if (network != null && !network.getSecurityManager().hasPermission(Permission.BUILD, ctx.getPlayer())) {
             WorldUtils.sendNoPermissionMessage(ctx.getPlayer());
 
             return ActionResultType.FAIL;
         }
-
         BlockState state = ctx.getWorld().getBlockState(ctx.getPos());
 
+        if (node instanceof ICoverable && ((ICoverable) node).getCoverManager().hasCover(ctx.getFace())){
+            Cover cover = ((ICoverable) node).getCoverManager().removeCover(ctx.getFace());
+            if (cover != null){
+                ItemStack stack1 = cover.getType().createStack();
+                CoverItem.setItem(stack1, cover.getStack());
+                ItemHandlerHelper.giveItemToPlayer(ctx.getPlayer(), stack1);
+                ctx.getWorld().notifyBlockUpdate(ctx.getPos(), state, state, 3);
+                ctx.getWorld().notifyNeighborsOfStateChange(ctx.getPos(), ctx.getWorld().getBlockState(ctx.getPos()).getBlock());
+                return ActionResultType.SUCCESS;
+            }
+        }
+
         ctx.getWorld().setBlockState(ctx.getPos(), state.rotate(ctx.getWorld(), ctx.getPos(), Rotation.CLOCKWISE_90));
 
         return ActionResultType.CONSUME;

src/main/java/com/refinedmods/refinedstorage/recipe/CoverRecipe.java

@@ -0,0 +1,111 @@
+package com.refinedmods.refinedstorage.recipe;
+
+
+import com.google.common.collect.Lists;
+import com.refinedmods.refinedstorage.RSItems;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import com.refinedmods.refinedstorage.item.WrenchItem;
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipeSerializer;
+import net.minecraft.item.crafting.SpecialRecipe;
+import net.minecraft.item.crafting.SpecialRecipeSerializer;
+import net.minecraft.tags.ItemTags;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+import net.minecraftforge.common.Tags;
+
+import java.util.List;
+
+public class CoverRecipe extends SpecialRecipe {
+
+    public static IRecipeSerializer<CoverRecipe> SERIALIZER = new SpecialRecipeSerializer<>(CoverRecipe::new);
+
+    public CoverRecipe(ResourceLocation idIn) {
+        super(idIn);
+    }
+
+    public static boolean stackMatches(ItemStack first) {
+        return CoverManager.isValidCover(first);
+    }
+
+    public static boolean matches(List<ItemStack> list) {
+        return list.size() == 2;
+    }
+
+    public static ItemStack getResult(List<ItemStack> list) {
+        if (list.size() == 2) {
+            ItemStack first = list.get(0);
+            ItemStack second = list.get(1);
+            return getResult(first, second);
+        }
+        return ItemStack.EMPTY;
+    }
+
+    public static ItemStack getResult(ItemStack first, ItemStack second){
+        if (first.getItem().isIn(Tags.Items.NUGGETS_IRON)){
+            ItemStack stack = new ItemStack(RSItems.COVER.get());
+            CoverItem.setItem(stack, second);
+            stack.setCount(6);
+            return stack;
+        }
+        if (second.getItem().isIn(Tags.Items.NUGGETS_IRON)){
+            ItemStack stack = new ItemStack(RSItems.COVER.get());
+            CoverItem.setItem(stack, first);
+            stack.setCount(6);
+            return stack;
+        }
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    public boolean matches(CraftingInventory inv, World worldIn) {
+        List<ItemStack> list = Lists.newArrayList();
+        int ingots = 0;
+        for (int i = 0; i < inv.getSizeInventory(); ++i) {
+            ItemStack itemstack = inv.getStackInSlot(i);
+            if (!itemstack.isEmpty()) {
+                list.add(itemstack);
+                if (itemstack.getItem().isIn(Tags.Items.NUGGETS_IRON)){
+                    ++ingots;
+                } else if (!stackMatches(itemstack)){
+                    return false;
+                }
+            }
+        }
+        return matches(list) && ingots == 1;
+    }
+
+    @Override
+    public ItemStack getCraftingResult(CraftingInventory inv) {
+        List<ItemStack> list = Lists.newArrayList();
+        int ingots = 0;
+        for (int i = 0; i < inv.getSizeInventory(); ++i) {
+            ItemStack itemstack = inv.getStackInSlot(i);
+            if (!itemstack.isEmpty()) {
+                list.add(itemstack);
+                if (itemstack.getItem().isIn(Tags.Items.NUGGETS_IRON)){
+                    ++ingots;
+                } else if (!stackMatches(itemstack)){
+                    return ItemStack.EMPTY;
+                }
+            }
+        }
+        if (ingots > 1){
+            return ItemStack.EMPTY;
+        }
+        return getResult(list);
+    }
+
+    @Override
+    public boolean canFit(int width, int height) {
+        return width * height >= 2;
+    }
+
+    @Override
+    public IRecipeSerializer<?> getSerializer() {
+        return SERIALIZER;
+    }
+}

src/main/java/com/refinedmods/refinedstorage/recipe/HollowCoverRecipe.java

@@ -0,0 +1,89 @@
+package com.refinedmods.refinedstorage.recipe;
+
+
+import com.google.common.collect.Lists;
+import com.refinedmods.refinedstorage.RSItems;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipeSerializer;
+import net.minecraft.item.crafting.SpecialRecipe;
+import net.minecraft.item.crafting.SpecialRecipeSerializer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.world.World;
+import net.minecraftforge.common.Tags;
+
+import java.util.List;
+
+public class HollowCoverRecipe extends SpecialRecipe {
+
+    public static IRecipeSerializer<HollowCoverRecipe> SERIALIZER = new SpecialRecipeSerializer<>(HollowCoverRecipe::new);
+
+    public HollowCoverRecipe(ResourceLocation idIn) {
+        super(idIn);
+    }
+
+    public static boolean stackMatches(ItemStack first) {
+        return first.getItem() == RSItems.COVER.get();
+    }
+
+    public static boolean matches(List<ItemStack> list) {
+        return list.size() == 1;
+    }
+
+    public static ItemStack getResult(List<ItemStack> list) {
+        if (list.size() == 1) {
+            ItemStack first = list.get(0);
+            return getResult(first);
+        }
+        return ItemStack.EMPTY;
+    }
+
+    public static ItemStack getResult(ItemStack first){
+        ItemStack stack = CoverItem.getItem(first);
+        ItemStack result = new ItemStack(RSItems.HOLLOW_COVER.get());
+        CoverItem.setItem(result, stack);
+        return result;
+    }
+
+    @Override
+    public boolean matches(CraftingInventory inv, World worldIn) {
+        List<ItemStack> list = Lists.newArrayList();
+        for (int i = 0; i < inv.getSizeInventory(); ++i) {
+            ItemStack itemstack = inv.getStackInSlot(i);
+            if (!itemstack.isEmpty()) {
+                list.add(itemstack);
+                if (!stackMatches(itemstack)){
+                    return false;
+                }
+            }
+        }
+        return matches(list);
+    }
+
+    @Override
+    public ItemStack getCraftingResult(CraftingInventory inv) {
+        List<ItemStack> list = Lists.newArrayList();
+        for (int i = 0; i < inv.getSizeInventory(); ++i) {
+            ItemStack itemstack = inv.getStackInSlot(i);
+            if (!itemstack.isEmpty()) {
+                list.add(itemstack);
+                if (!stackMatches(itemstack)){
+                    return ItemStack.EMPTY;
+                }
+            }
+        }
+        return getResult(list);
+    }
+
+    @Override
+    public boolean canFit(int width, int height) {
+        return width * height >= 2;
+    }
+
+    @Override
+    public IRecipeSerializer<?> getSerializer() {
+        return SERIALIZER;
+    }
+}

src/main/java/com/refinedmods/refinedstorage/render/ConstantsCable.java

@@ -0,0 +1,97 @@
+package com.refinedmods.refinedstorage.render;
+
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
+import com.refinedmods.refinedstorage.render.collision.CollisionGroup;
+import com.refinedmods.refinedstorage.tile.NetworkNodeTile;
+import com.refinedmods.refinedstorage.util.CollisionUtils;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.util.math.shapes.VoxelShapes;
+import net.minecraft.world.IBlockReader;
+import net.minecraft.world.IWorldReader;
+
+import javax.annotation.Nonnull;
+
+public class ConstantsCable {
+
+    public static final CollisionGroup CORE = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 6, 10, 10, 10));
+    public static final CollisionGroup NORTH = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 0, 10, 10, 6));
+    public static final CollisionGroup EAST = new CollisionGroup().addItem(CollisionUtils.getBounds(10, 6, 6, 16, 10, 10));
+    public static final CollisionGroup SOUTH = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 6, 10, 10, 10, 16));
+    public static final CollisionGroup WEST = new CollisionGroup().addItem(CollisionUtils.getBounds(0, 6, 6, 6, 10, 10));
+    public static final CollisionGroup UP = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 10, 6, 10, 16, 10));
+    public static final CollisionGroup DOWN = new CollisionGroup().addItem(CollisionUtils.getBounds(6, 0, 6, 10, 6, 10));
+
+    public static final CollisionGroup HOLDER_NORTH = new CollisionGroup().addItem(getHolderBounds(Direction.NORTH));
+    public static final CollisionGroup HOLDER_EAST = new CollisionGroup().addItem(getHolderBounds(Direction.EAST));
+    public static final CollisionGroup HOLDER_SOUTH = new CollisionGroup().addItem(getHolderBounds(Direction.SOUTH));
+    public static final CollisionGroup HOLDER_WEST = new CollisionGroup().addItem(getHolderBounds(Direction.WEST));
+    public static final CollisionGroup HOLDER_UP = new CollisionGroup().addItem(getHolderBounds(Direction.UP));
+    public static final CollisionGroup HOLDER_DOWN = new CollisionGroup().addItem(getHolderBounds(Direction.DOWN));
+
+    @Nonnull
+    public static AxisAlignedBB getCoverBounds(Direction side) {
+        switch (side) {
+            case DOWN:
+                return CollisionUtils.getBounds(0, 0, 0, 16, 2, 16);
+            case UP:
+                return CollisionUtils.getBounds(0, 14, 0, 16, 16, 16);
+            case NORTH:
+                return CollisionUtils.getBounds(0, 0, 0, 16, 16, 2);
+            case SOUTH:
+                return CollisionUtils.getBounds(0, 0, 14, 16, 16, 16);
+            case WEST:
+                return CollisionUtils.getBounds(0, 0, 0, 2, 16, 16);
+            case EAST:
+                return CollisionUtils.getBounds(14, 0, 0, 16, 16, 16);
+            default:
+                return null;
+        }
+    }
+
+    @Nonnull
+    public static AxisAlignedBB getHolderBounds(Direction side) {
+        switch (side) {
+            case DOWN:
+                return CollisionUtils.getBounds(7, 2, 7, 9, 6, 9);
+            case UP:
+                return CollisionUtils.getBounds(7, 10, 7, 9, 14, 9);
+            case NORTH:
+                return CollisionUtils.getBounds(7, 7, 2, 9, 9, 6);
+            case SOUTH:
+                return CollisionUtils.getBounds(7, 7, 10, 9, 9, 14);
+            case WEST:
+                return CollisionUtils.getBounds(2, 7, 7, 6, 9, 9);
+            case EAST:
+                return CollisionUtils.getBounds(10, 7, 7, 14, 9, 9);
+            default:
+                return null;
+        }
+    }
+
+    public static VoxelShape addCoverVoxelShapes(VoxelShape shape, IBlockReader world, BlockPos pos){
+        if (world != null) {
+            TileEntity entity = world.getTileEntity(pos);
+            if (entity instanceof NetworkNodeTile && ((NetworkNodeTile<?>) entity).getNode() instanceof ICoverable) {
+                CoverManager coverManager = ((ICoverable) ((NetworkNodeTile<?>) entity).getNode()).getCoverManager();
+                for (Direction value : Direction.values()) {
+                    Cover cover = coverManager.getCover(value);
+                    if (cover != null) {
+                        shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getCoverBounds(value)));
+                        if (cover.getType() == CoverType.NORMAL) {
+                            shape = VoxelShapes.or(shape, VoxelShapes.create(ConstantsCable.getHolderBounds(value)));
+                        }
+                    }
+                }
+            }
+        }
+        return shape;
+    }
+
+}

src/main/java/com/refinedmods/refinedstorage/render/collision/CollisionGroup.java

@@ -0,0 +1,48 @@
+package com.refinedmods.refinedstorage.render.collision;
+
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.AxisAlignedBB;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CollisionGroup {
+
+    private List<AxisAlignedBB> items = new ArrayList<>();
+    private boolean canAccessGui;
+    @Nullable
+    private Direction direction;
+
+    public CollisionGroup addItem(AxisAlignedBB item) {
+        items.add(item);
+
+        return this;
+    }
+
+    public List<AxisAlignedBB> getItems() {
+        return items;
+    }
+
+    public boolean canAccessGui() {
+        return canAccessGui;
+    }
+
+    public CollisionGroup setCanAccessGui(boolean canAccessGui) {
+        this.canAccessGui = canAccessGui;
+
+        return this;
+    }
+
+    public CollisionGroup setDirection(Direction direction) {
+        this.direction = direction;
+
+        return this;
+    }
+
+    @Nullable
+    public Direction getDirection() {
+        return direction;
+    }
+    
+}

src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCableCover.java

@@ -0,0 +1,364 @@
+package com.refinedmods.refinedstorage.render.model;
+
+import com.refinedmods.refinedstorage.RS;
+import com.refinedmods.refinedstorage.RSBlocks;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.block.BaseBlock;
+import com.refinedmods.refinedstorage.render.ConstantsCable;
+import com.refinedmods.refinedstorage.util.RenderUtils;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.Atlases;
+import net.minecraft.client.renderer.model.BakedQuad;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.client.renderer.texture.AtlasTexture;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.util.Direction;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.vector.Vector3f;
+import net.minecraftforge.client.model.data.IModelData;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+public class BakedModelCableCover extends DelegateBakedModel{
+
+    private static TextureAtlasSprite BORDER_SPRITE;
+
+    public BakedModelCableCover(IBakedModel base) {
+        super(base);
+    }
+
+    @Override
+    public List<BakedQuad> getQuads(@Nullable BlockState state, @Nullable Direction side, Random rand, IModelData data) {
+        List<BakedQuad> quads = new ArrayList<>(base.getQuads(state, side, rand, data));
+        if (data != null && data.hasProperty(CoverManager.PROPERTY)) {
+            CoverManager manager = data.getData(CoverManager.PROPERTY);
+            addCover(quads, manager.getCover(Direction.NORTH), Direction.NORTH, side, rand, manager, state, true);
+            addCover(quads, manager.getCover(Direction.SOUTH), Direction.SOUTH, side, rand, manager, state, true);
+            addCover(quads, manager.getCover(Direction.EAST), Direction.EAST, side, rand, manager, state, true);
+            addCover(quads, manager.getCover(Direction.WEST), Direction.WEST, side, rand, manager, state, true);
+            addCover(quads, manager.getCover(Direction.DOWN), Direction.DOWN, side, rand, manager, state, true);
+            addCover(quads, manager.getCover(Direction.UP), Direction.UP, side, rand, manager, state, true);
+        }
+        return quads;
+    }
+
+    private static int getHollowCoverSize(@Nullable BlockState state, Direction coverSide) {
+        if (state == null) {
+            return 6;
+        }
+
+        BaseBlock block = (BaseBlock) state.getBlock();
+        if (block == RSBlocks.CABLE.get()){
+            return 6;
+        }
+
+        if (block.getDirection() != null && state.get(block.getDirection().getProperty()) == coverSide) {
+            if (block == RSBlocks.EXPORTER.get()) {
+                return 6;
+            } else if (block == RSBlocks.EXTERNAL_STORAGE.get() || block == RSBlocks.IMPORTER.get()) {
+                return 3;
+            } else if (block == RSBlocks.CONSTRUCTOR.get() || block == RSBlocks.DESTRUCTOR.get()) { //Removed reader and writer
+                return 2;
+            }
+        }
+
+        return 6;
+    }
+
+    protected static void addCover(List<BakedQuad> quads, @Nullable Cover cover, Direction coverSide, Direction side, Random rand, @Nullable CoverManager manager, BlockState state,  boolean handle) {
+        if (cover == null) {
+            return;
+        }
+
+        BlockState coverState = CoverManager.getBlockState(cover.getStack());
+
+        if (coverState == null) {
+            return;
+        }
+
+        boolean hasUp = false, hasDown = false, hasEast = false, hasWest = false;
+
+        if (manager != null) {
+            hasUp = manager.hasCover(Direction.UP);
+            hasDown = manager.hasCover(Direction.DOWN);
+            hasEast = manager.hasCover(Direction.EAST);
+            hasWest = manager.hasCover(Direction.WEST);
+        }
+
+        switch (cover.getType()) {
+            case NORMAL:
+                addNormalCover(quads, coverState, coverSide, hasUp, hasDown, hasEast, hasWest, handle, rand);
+                break;
+            case HOLLOW:
+                addHollowCover(quads, coverState, coverSide, hasUp, hasDown, hasEast, hasWest, getHollowCoverSize(state, coverSide), rand);
+                break;
+        }
+    }
+
+    private static void addNormalCover(List<BakedQuad> quads, BlockState state, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, boolean handle, Random random) {
+        AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide);
+
+        Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16);
+        Vector3f to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16);
+
+        if (coverSide == Direction.NORTH) {
+            if (hasWest) {
+                from.setX(2);
+            }
+
+            if (hasEast) {
+                to.setX(14);
+            }
+        } else if (coverSide == Direction.SOUTH) {
+            if (hasWest) {
+                from.setX(2);
+            }
+
+            if (hasEast) {
+                to.setX(14);
+            }
+        }
+
+        if (coverSide.getAxis() != Direction.Axis.Y) {
+            if (hasDown) {
+                from.setY(2);
+            }
+
+            if (hasUp) {
+                to.setY(14);
+            }
+        }
+
+        HashMap<Direction, TextureAtlasSprite> spriteCache = new HashMap<>();  //Changed from 1.12: to improve sprite getting for each side
+        quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random)))).bake());
+
+        if (handle) {
+            if (BORDER_SPRITE == null) {
+                BORDER_SPRITE = Minecraft.getInstance().getAtlasSpriteGetter(AtlasTexture.LOCATION_BLOCKS_TEXTURE).apply(new ResourceLocation(RS.ID , "block/cable_part_border"));
+            }
+
+            bounds = ConstantsCable.getHolderBounds(coverSide);
+
+            from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16);
+            to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16);
+
+            quads.addAll(new CubeBuilder().from(from.getX(), from.getY(), from.getZ()).to(to.getX(), to.getY(), to.getZ()).addFaces(face -> new CubeBuilder.Face(face, BORDER_SPRITE)).bake());
+        }
+    }
+
+    private static void addHollowCover(List<BakedQuad> quads, BlockState state, Direction coverSide, boolean hasUp, boolean hasDown, boolean hasEast, boolean hasWest, int size, Random random) {
+        AxisAlignedBB bounds = ConstantsCable.getCoverBounds(coverSide);
+
+        Vector3f from = new Vector3f((float) bounds.minX * 16, (float) bounds.minY * 16, (float) bounds.minZ * 16);
+        Vector3f to = new Vector3f((float) bounds.maxX * 16, (float) bounds.maxY * 16, (float) bounds.maxZ * 16);
+
+        if (coverSide.getAxis() != Direction.Axis.Y) {
+            if (hasDown) {
+                from.setY(2);
+            }
+
+            if (hasUp) {
+                to.setY(14);
+            }
+        }
+
+        // Right
+        if (coverSide == Direction.NORTH) {
+            if (hasWest) {
+                from.setX(2);
+            } else {
+                from.setX(0);
+            }
+
+            to.setX(size);
+        } else if (coverSide == Direction.SOUTH) {
+            if (hasEast) {
+                to.setX(14);
+            } else {
+                to.setX(16);
+            }
+
+            from.setX(16 - size);
+        } else if (coverSide == Direction.EAST) {
+            from.setZ(0);
+            to.setZ(size);
+        } else if (coverSide == Direction.WEST) {
+            from.setZ(16 - size);
+            to.setZ(16);
+        } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) {
+            from.setZ(16 - size);
+            to.setZ(16);
+        }
+        HashMap<Direction, TextureAtlasSprite> spriteCache = new HashMap<>(); //Changed from 1.12: to improve sprite getting for each side
+        quads.addAll(new CubeBuilder()
+                .from(from.getX(), from.getY(), from.getZ())
+                .to(to.getX(), to.getY(), to.getZ())
+                .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random))))
+                .bake()
+        );
+
+        // Left
+        if (coverSide == Direction.NORTH) {
+            if (hasEast) {
+                to.setX(14);
+            } else {
+                to.setX(16);
+            }
+
+            from.setX(16 - size);
+        } else if (coverSide == Direction.SOUTH) {
+            if (hasWest) {
+                from.setX(2);
+            } else {
+                from.setX(0);
+            }
+
+            to.setX(size);
+        } else if (coverSide == Direction.EAST) {
+            from.setZ(16 - size);
+            to.setZ(16);
+        } else if (coverSide == Direction.WEST) {
+            from.setZ(0);
+            to.setZ(size);
+        } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) {
+            from.setZ(0);
+            to.setZ(size);
+        }
+
+        quads.addAll(new CubeBuilder()
+                .from(from.getX(), from.getY(), from.getZ())
+                .to(to.getX(), to.getY(), to.getZ())
+                .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random))))
+                .bake()
+        );
+
+        // Bottom
+        if (coverSide == Direction.NORTH) {
+            from.setX(size);
+            to.setX(16 - size);
+
+            if (hasDown) {
+                from.setY(2);
+            } else {
+                from.setY(0);
+            }
+
+            to.setY(size);
+        } else if (coverSide == Direction.SOUTH) {
+            from.setX(size);
+            to.setX(16 - size);
+
+            if (hasDown) {
+                from.setY(2);
+            } else {
+                from.setY(0);
+            }
+
+            to.setY(size);
+        } else if (coverSide == Direction.EAST) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            if (hasDown) {
+                from.setY(2);
+            } else {
+                from.setY(0);
+            }
+
+            to.setY(size);
+        } else if (coverSide == Direction.WEST) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            if (hasDown) {
+                from.setY(2);
+            } else {
+                from.setY(0);
+            }
+
+            to.setY(size);
+        } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            from.setX(0);
+            to.setX(size);
+        }
+
+        quads.addAll(new CubeBuilder()
+                .from(from.getX(), from.getY(), from.getZ())
+                .to(to.getX(), to.getY(), to.getZ())
+                .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random))))
+                .bake()
+        );
+
+        // Up
+        if (coverSide == Direction.NORTH) {
+            from.setX(size);
+            to.setX(16 - size);
+
+            if (hasUp) {
+                to.setY(14);
+            } else {
+                to.setY(16);
+            }
+
+            from.setY(16 - size);
+        } else if (coverSide == Direction.SOUTH) {
+            from.setX(size);
+            to.setX(16 - size);
+
+            if (hasUp) {
+                to.setY(14);
+            } else {
+                to.setY(16);
+            }
+
+            from.setY(16 - size);
+        } else if (coverSide == Direction.EAST) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            if (hasUp) {
+                to.setY(14);
+            } else {
+                to.setY(16);
+            }
+
+            from.setY(16 - size);
+        } else if (coverSide == Direction.WEST) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            if (hasUp) {
+                to.setY(14);
+            } else {
+                to.setY(16);
+            }
+
+            from.setY(16 - size);
+        } else if (coverSide == Direction.DOWN || coverSide == Direction.UP) {
+            from.setZ(size);
+            to.setZ(16 - size);
+
+            from.setX(16 - size);
+            to.setX(16);
+        }
+
+        quads.addAll(new CubeBuilder()
+                .from(from.getX(), from.getY(), from.getZ())
+                .to(to.getX(), to.getY(), to.getZ())
+                .addFaces(face -> new CubeBuilder.Face(face, spriteCache.computeIfAbsent(face, direction -> RenderUtils.getSprite(Minecraft.getInstance().getBlockRendererDispatcher().getModelForState(state), state, direction, random))))
+                .bake()
+        );
+    }
+}
+

src/main/java/com/refinedmods/refinedstorage/render/model/BakedModelCover.java

@@ -0,0 +1,151 @@
+package com.refinedmods.refinedstorage.render.model;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.Cover;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
+import com.refinedmods.refinedstorage.item.CoverItem;
+import com.refinedmods.refinedstorage.util.RenderUtils;
+import net.minecraft.block.BlockState;
+import net.minecraft.client.renderer.model.BakedQuad;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.client.renderer.model.ItemCameraTransforms;
+import net.minecraft.client.renderer.model.ItemOverrideList;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.vector.TransformationMatrix;
+
+import javax.annotation.Nullable;
+import java.util.*;
+
+public class BakedModelCover extends BakedModelCableCover{
+
+    private class CacheKey {
+        private BlockState state;
+        private ItemStack stack;
+        private Direction side;
+        private CoverType type;
+
+        CacheKey(BlockState state, ItemStack stack, Direction side, CoverType type) {
+            this.state = state;
+            this.stack = stack;
+            this.side = side;
+            this.type = type;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+
+            BakedModelCover.CacheKey cacheKey = (BakedModelCover.CacheKey) o;
+
+            return cacheKey.type == type && cacheKey.stack.getItem() == stack.getItem() /* && cacheKey.stack.getItemDamage() == stack.getItemDamage()*/ && cacheKey.side == side && Objects.equals(cacheKey.state, state);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = stack.getItem().hashCode();
+            //result = 31 * result + stack.getDamage();
+            result = 31 * result + (side != null ? side.hashCode() : 0);
+            result = 31 * result + (state != null ? state.hashCode() : 0);
+            result = 31 * result + type.hashCode();
+            return result;
+        }
+    }
+
+    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<>();
+
+            addCover(quads, new Cover(key.stack, key.type), Direction.NORTH, key.side, new Random(), null, null, true);
+
+            return quads;
+        }
+    });
+
+    private ItemStack stack;
+    private CoverType type;
+
+    public BakedModelCover(ItemStack stack, CoverType type) {
+        super(null);
+
+        this.stack = stack;
+        this.type = type;
+    }
+
+    @Override
+    public List<BakedQuad> getQuads(@Nullable BlockState state, @Nullable Direction side, Random rand) {
+        if (stack.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        CacheKey key = new CacheKey(state, CoverItem.getItem(stack), side, type);
+
+        return CACHE.getUnchecked(key);
+    }
+
+    @Override
+    public ItemOverrideList getOverrides() {
+        return new ItemOverrideList() {
+            @Override
+            public IBakedModel getOverrideModel(IBakedModel originalModel, ItemStack stack, @Nullable ClientWorld world, @Nullable LivingEntity entity) {
+                return new BakedModelCover(stack, type);
+            }
+        };
+    }
+
+    @Override
+    public IBakedModel handlePerspective(ItemCameraTransforms.TransformType cameraTransformType, MatrixStack matrixStack) {
+        TransformationMatrix transform = RenderUtils.getDefaultBlockTransforms().get(cameraTransformType);
+        if (transform != null) transform.push(matrixStack);
+        return this;
+    }
+
+    @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(BlockState state) {
+        return true;
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public ItemCameraTransforms getItemCameraTransforms() {
+        return ItemCameraTransforms.DEFAULT;
+    }
+
+    @Override
+    public boolean isSideLit() {
+        return true;
+    }
+}

src/main/java/com/refinedmods/refinedstorage/render/model/CubeBuilder.java

@@ -0,0 +1,353 @@
+package com.refinedmods.refinedstorage.render.model;
+
+import com.refinedmods.refinedstorage.util.RenderUtils;
+import net.minecraft.client.renderer.model.BakedQuad;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.client.renderer.vertex.VertexFormatElement;
+import net.minecraft.util.Direction;
+import net.minecraft.util.math.vector.Vector3f;
+import net.minecraftforge.client.model.pipeline.BakedQuadBuilder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class CubeBuilder {
+
+    public enum UvRotation {
+        CLOCKWISE_0,
+        CLOCKWISE_90,
+        CLOCKWISE_180,
+        CLOCKWISE_270
+    }
+
+    private static class Uv {
+        private float xFrom;
+        private float xTo;
+        private float yFrom;
+        private float yTo;
+    }
+
+    public static class Face {
+        private Direction face;
+        private TextureAtlasSprite sprite;
+        private int light;
+        private UvRotation uvRotation = UvRotation.CLOCKWISE_0;
+
+        public Face(Direction face, TextureAtlasSprite sprite) {
+            this.face = face;
+            this.sprite = sprite;
+        }
+
+        public Face(Direction face, TextureAtlasSprite sprite, UvRotation uvRotation) {
+            this(face, sprite);
+
+            this.uvRotation = uvRotation;
+        }
+
+        public Face(Direction face, TextureAtlasSprite sprite, UvRotation uvRotation, int light) {
+            this(face, sprite, uvRotation);
+
+            this.light = light;
+        }
+    }
+
+    private Vector3f from;
+    private Vector3f to;
+    private VertexFormat format = DefaultVertexFormats.BLOCK; //Changed from Item
+    private Map<Direction, Face> faces = new HashMap<>();
+    private int color = 0xFFFFFFFF;
+
+    public CubeBuilder from(float x, float y, float z) {
+        this.from = new Vector3f(x / 16, y / 16, z / 16);
+
+        return this;
+    }
+
+    public CubeBuilder to(float x, float y, float z) {
+        this.to = new Vector3f(x / 16, y / 16, z / 16);
+
+        return this;
+    }
+
+    public CubeBuilder color(int color) {
+        this.color = color;
+
+        return this;
+    }
+
+    public CubeBuilder lightmap() {
+        this.format = RenderUtils.getFormatWithLightMap(format);
+
+        return this;
+    }
+
+    public CubeBuilder addFaces(Function<Direction, Face> faceSupplier) {
+        for (Direction facing : Direction.values()) {
+            addFace(faceSupplier.apply(facing));
+        }
+
+        return this;
+    }
+
+    public CubeBuilder addFace(Face face) {
+        faces.put(face.face, face);
+
+        return this;
+    }
+
+    public List<BakedQuad> bake() {
+        List<BakedQuad> quads = new ArrayList<>();
+
+        for (Map.Entry<Direction, Face> entry : faces.entrySet()) {
+            quads.add(bakeFace(entry.getKey(), entry.getValue()));
+        }
+
+        return quads;
+    }
+
+    private BakedQuad bakeFace(Direction facing, Face cubeFace) {
+        BakedQuadBuilder builder = new BakedQuadBuilder(cubeFace.sprite);
+
+        builder.setQuadOrientation(facing);
+        builder.setQuadTint(-1);
+        builder.setApplyDiffuseLighting(true);
+
+        Uv uv = getDefaultUv(facing, cubeFace.sprite, from.getX(), from.getY(), from.getZ(), to.getX(), to.getY(), to.getZ());
+
+        switch (facing) {
+            case DOWN:
+                addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv);
+                addVertexBottomRight(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv);
+                addVertexBottomLeft(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv);
+                addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv);
+                break;
+            case UP:
+                addVertexTopLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv);
+                addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv);
+                addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv);
+                addVertexTopRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv);
+                break;
+            case NORTH:
+                addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv);
+                addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv);
+                addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv);
+                addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv);
+                break;
+            case SOUTH:
+                addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv);
+                addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv);
+                addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv);
+                addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv);
+                break;
+            case WEST:
+                addVertexTopLeft(builder, cubeFace, from.getX(), from.getY(), from.getZ(), uv);
+                addVertexTopRight(builder, cubeFace, from.getX(), from.getY(), to.getZ(), uv);
+                addVertexBottomRight(builder, cubeFace, from.getX(), to.getY(), to.getZ(), uv);
+                addVertexBottomLeft(builder, cubeFace, from.getX(), to.getY(), from.getZ(), uv);
+                break;
+            case EAST:
+                addVertexBottomRight(builder, cubeFace, to.getX(), to.getY(), from.getZ(), uv);
+                addVertexBottomLeft(builder, cubeFace, to.getX(), to.getY(), to.getZ(), uv);
+                addVertexTopLeft(builder, cubeFace, to.getX(), from.getY(), to.getZ(), uv);
+                addVertexTopRight(builder, cubeFace, to.getX(), from.getY(), from.getZ(), uv);
+                break;
+        }
+
+        return builder.build();
+    }
+
+    private Uv getDefaultUv(Direction face, TextureAtlasSprite texture, float fromX, float fromY, float fromZ, float toX, float toY, float toZ) {
+        Uv uv = new Uv();
+
+        switch (face) {
+            case DOWN:
+                uv.xFrom = texture.getInterpolatedU(fromX * 16);
+                uv.yFrom = texture.getInterpolatedV(16 - fromZ * 16);
+                uv.xTo = texture.getInterpolatedU(toX * 16);
+                uv.yTo = texture.getInterpolatedV(16 - toZ * 16);
+                break;
+            case UP:
+                uv.xFrom = texture.getInterpolatedU(fromX * 16);
+                uv.yFrom = texture.getInterpolatedV(fromZ * 16);
+                uv.xTo = texture.getInterpolatedU(toX * 16);
+                uv.yTo = texture.getInterpolatedV(toZ * 16);
+                break;
+            case NORTH:
+                uv.xFrom = texture.getInterpolatedU(16 - fromX * 16);
+                uv.yFrom = texture.getInterpolatedV(16 - fromY * 16);
+                uv.xTo = texture.getInterpolatedU(16 - toX * 16);
+                uv.yTo = texture.getInterpolatedV(16 - toY * 16);
+                break;
+            case SOUTH:
+                uv.xFrom = texture.getInterpolatedU(fromX * 16);
+                uv.yFrom = texture.getInterpolatedV(16 - fromY * 16);
+                uv.xTo = texture.getInterpolatedU(toX * 16);
+                uv.yTo = texture.getInterpolatedV(16 - toY * 16);
+                break;
+            case WEST:
+                uv.xFrom = texture.getInterpolatedU(fromZ * 16);
+                uv.yFrom = texture.getInterpolatedV(16 - fromY * 16);
+                uv.xTo = texture.getInterpolatedU(toZ * 16);
+                uv.yTo = texture.getInterpolatedV(16 - toY * 16);
+                break;
+            case EAST:
+                uv.xFrom = texture.getInterpolatedU(16 - toZ * 16);
+                uv.yFrom = texture.getInterpolatedV(16 - fromY * 16);
+                uv.xTo = texture.getInterpolatedU(16 - fromZ * 16);
+                uv.yTo = texture.getInterpolatedV(16 - toY * 16);
+                break;
+        }
+
+        return uv;
+    }
+
+    private void addVertexTopLeft(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) {
+        float u;
+        float v;
+
+        switch (face.uvRotation) {
+            default:
+            case CLOCKWISE_0:
+                u = uv.xFrom;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_90:
+                u = uv.xFrom;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_180:
+                u = uv.xTo;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_270:
+                u = uv.xTo;
+                v = uv.yFrom;
+                break;
+        }
+
+        addVertex(builder, face, x, y, z, u, v);
+    }
+
+    private void addVertexTopRight(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) {
+        float u;
+        float v;
+
+        switch (face.uvRotation) {
+            default:
+            case CLOCKWISE_0:
+                u = uv.xTo;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_90:
+                u = uv.xFrom;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_180:
+                u = uv.xFrom;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_270:
+                u = uv.xTo;
+                v = uv.yTo;
+                break;
+        }
+
+        addVertex(builder, face, x, y, z, u, v);
+    }
+
+    private void addVertexBottomRight(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) {
+        float u;
+        float v;
+
+        switch (face.uvRotation) {
+            default:
+            case CLOCKWISE_0:
+                u = uv.xTo;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_90:
+                u = uv.xTo;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_180:
+                u = uv.xFrom;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_270:
+                u = uv.xFrom;
+                v = uv.yTo;
+                break;
+        }
+
+        addVertex(builder, face, x, y, z, u, v);
+    }
+
+    private void addVertexBottomLeft(BakedQuadBuilder builder, Face face, float x, float y, float z, Uv uv) {
+        float u;
+        float v;
+
+        switch (face.uvRotation) {
+            default:
+            case CLOCKWISE_0:
+                u = uv.xFrom;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_90:
+                u = uv.xTo;
+                v = uv.yTo;
+                break;
+            case CLOCKWISE_180:
+                u = uv.xTo;
+                v = uv.yFrom;
+                break;
+            case CLOCKWISE_270:
+                u = uv.xFrom;
+                v = uv.yFrom;
+                break;
+        }
+
+        addVertex(builder, face, x, y, z, u, v);
+    }
+
+    private void addVertex(BakedQuadBuilder builder, Face face, float x, float y, float z, float u, float v) {
+        VertexFormat format = builder.getVertexFormat();
+
+        for (int i = 0; i < format.getElements().size(); i++) {
+            VertexFormatElement e = format.getElements().get(i);
+
+            switch (e.getUsage()) {
+                case POSITION:
+                    builder.put(i, x, y, z);
+                    break;
+                case NORMAL:
+                    builder.put(i, face.face.getXOffset(), face.face.getYOffset(), face.face.getZOffset());
+                    break;
+                case COLOR:
+                    float r = (color >> 16 & 0xFF) / 255F;
+                    float g = (color >> 8 & 0xFF) / 255F;
+                    float b = (color & 0xFF) / 255F;
+                    float a = (color >> 24 & 0xFF) / 255F;
+
+                    builder.put(i, r, g, b, a);
+                    break;
+                case UV:
+                    if (e.getIndex() == 0) {
+                        builder.put(i, u, v);
+                    } else {
+                        builder.put(i, (float) (face.light * 0x20) / 0xFFFF, (float) (face.light * 0x20) / 0xFFFF);
+                    }
+
+                    break;
+                default:
+                    builder.put(i);
+                    break;
+            }
+        }
+    }
+    
+}

src/main/java/com/refinedmods/refinedstorage/setup/ClientSetup.java

@@ -2,6 +2,7 @@ package com.refinedmods.refinedstorage.setup;
 
 import com.refinedmods.refinedstorage.*;
 import com.refinedmods.refinedstorage.apiimpl.API;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverType;
 import com.refinedmods.refinedstorage.container.CrafterContainer;
 import com.refinedmods.refinedstorage.container.CrafterManagerContainer;
 import com.refinedmods.refinedstorage.container.slot.CrafterManagerSlot;
@@ -22,12 +23,17 @@ import net.minecraft.client.gui.ScreenManager;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.RenderTypeLookup;
+import net.minecraft.client.renderer.texture.AtlasTexture;
 import net.minecraft.inventory.container.Container;
 import net.minecraft.inventory.container.Slot;
 import net.minecraft.item.DyeColor;
 import net.minecraft.item.ItemModelsProperties;
+import net.minecraft.item.ItemStack;
+import net.minecraft.resources.IReloadableResourceManager;
+import net.minecraft.resources.IResourceManager;
 import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.client.event.ModelBakeEvent;
+import net.minecraftforge.client.event.TextureStitchEvent;
 import net.minecraftforge.client.event.ModelRegistryEvent;
 import net.minecraftforge.client.model.ModelLoader;
 import net.minecraftforge.common.MinecraftForge;
@@ -85,8 +91,6 @@ public class ClientSetup {
                 "block/security_manager/cutouts/right_")
         )));
         forEachColorApply("wireless_transmitter", (name, color) -> bakedModelOverrideRegistry.add(name, (base, registry) -> new FullbrightBakedModel(base, true, getColoredModel(color, "block/wireless_transmitter/cutouts/"))));
-        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "constructor"), (base, registry) -> new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/constructor/cutouts/connected")));
-        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "destructor"), (base, registry) -> new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/destructor/cutouts/connected")));
 
         bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "disk_drive"), (base, registry) -> new FullbrightBakedModel(
             new DiskDriveBakedModel(
@@ -99,6 +103,14 @@ public class ClientSetup {
             false,
             new ResourceLocation(RS.ID, "block/disks/leds")
         ));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cable"), (base, registry) -> new BakedModelCableCover(base));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "exporter"), (base, registry) -> new BakedModelCableCover(base));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "importer"), (base, registry) -> new BakedModelCableCover(base));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "constructor"), (base, registry) ->  new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/constructor/cutouts/connected"))));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "destructor"), (base, registry) -> new BakedModelCableCover(new FullbrightBakedModel(base, true, new ResourceLocation(RS.ID, "block/destructor/cutouts/connected"))));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "external_storage"), (base, registry) -> new BakedModelCableCover(base));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.NORMAL));
+        bakedModelOverrideRegistry.add(new ResourceLocation(RS.ID, "hollow_cover"), (base, registry) -> new BakedModelCover(ItemStack.EMPTY, CoverType.HOLLOW));
 
         forEachColorApply("disk_manipulator", (name, color) -> bakedModelOverrideRegistry.add(name, (base, registry) -> new FullbrightBakedModel(
             new DiskManipulatorBakedModel(
@@ -143,6 +155,7 @@ public class ClientSetup {
         FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onModelBake);
         FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onModelRegistry);
         MinecraftForge.EVENT_BUS.addListener(this::addReloadListener);
+        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onTextureStitch);
 
         API.instance().addPatternRenderHandler(pattern -> Screen.hasShiftDown());
 
@@ -306,4 +319,10 @@ public class ClientSetup {
             }
         }
     }
+
+    @SubscribeEvent
+    public void onTextureStitch(TextureStitchEvent.Pre event){
+        if (event.getMap().getTextureLocation().equals(AtlasTexture.LOCATION_BLOCKS_TEXTURE))
+            event.addSprite(new ResourceLocation(RS.ID ,"block/cable_part_border"));
+    }
 }

src/main/java/com/refinedmods/refinedstorage/setup/CommonSetup.java

@@ -35,6 +35,8 @@ import com.refinedmods.refinedstorage.container.factory.*;
 import com.refinedmods.refinedstorage.integration.craftingtweaks.CraftingTweaksIntegration;
 import com.refinedmods.refinedstorage.integration.inventorysorter.InventorySorterIntegration;
 import com.refinedmods.refinedstorage.item.blockitem.PortableGridBlockItem;
+import com.refinedmods.refinedstorage.recipe.CoverRecipe;
+import com.refinedmods.refinedstorage.recipe.HollowCoverRecipe;
 import com.refinedmods.refinedstorage.recipe.UpgradeWithEnchantedBookRecipeSerializer;
 import com.refinedmods.refinedstorage.tile.*;
 import com.refinedmods.refinedstorage.tile.craftingmonitor.CraftingMonitorTile;
@@ -46,6 +48,7 @@ import net.minecraft.item.crafting.IRecipeSerializer;
 import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityType;
+import net.minecraft.util.ResourceLocation;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.common.extensions.IForgeContainerType;
 import net.minecraftforge.event.RegistryEvent;
@@ -141,6 +144,8 @@ public class CommonSetup {
     @SubscribeEvent
     public void onRegisterRecipeSerializers(RegistryEvent.Register<IRecipeSerializer<?>> e) {
         e.getRegistry().register(new UpgradeWithEnchantedBookRecipeSerializer().setRegistryName(RS.ID, "upgrade_with_enchanted_book"));
+        e.getRegistry().register(CoverRecipe.SERIALIZER.setRegistryName(new ResourceLocation(RS.ID, "cover_recipe")));
+        e.getRegistry().register(HollowCoverRecipe.SERIALIZER.setRegistryName(new ResourceLocation(RS.ID, "hollow_cover_recipe")));
     }
 
     @SubscribeEvent

src/main/java/com/refinedmods/refinedstorage/tile/CableTile.java

@@ -1,15 +1,43 @@
 package com.refinedmods.refinedstorage.tile;
 
 import com.refinedmods.refinedstorage.RSTiles;
+import com.refinedmods.refinedstorage.api.network.node.ICoverable;
 import com.refinedmods.refinedstorage.apiimpl.network.node.CableNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.DiskState;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
+import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.client.Minecraft;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.IntNBT;
+import net.minecraft.nbt.ListNBT;
+import net.minecraft.network.datasync.DataSerializers;
+import net.minecraft.network.datasync.IDataSerializer;
+import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.ModelDataManager;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
+import net.minecraftforge.client.model.data.ModelProperty;
+import net.minecraftforge.common.util.Constants;
 
 import javax.annotation.Nonnull;
+import java.util.HashMap;
 
 public class CableTile extends NetworkNodeTile<CableNetworkNode> {
+
+    public static final TileDataParameter<CompoundNBT, CableTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public CableTile() {
         super(RSTiles.CABLE);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -17,4 +45,32 @@ public class CableTile extends NetworkNodeTile<CableNetworkNode> {
     public CableNetworkNode createNode(World world, BlockPos pos) {
         return new CableNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
+
+
 }

src/main/java/com/refinedmods/refinedstorage/tile/ConstructorTile.java

@@ -2,12 +2,19 @@ package com.refinedmods.refinedstorage.tile;
 
 import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.apiimpl.network.node.ConstructorNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.tile.config.IComparable;
 import com.refinedmods.refinedstorage.tile.config.IType;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
 
 import javax.annotation.Nonnull;
 
@@ -19,12 +26,18 @@ public class ConstructorTile extends NetworkNodeTile<ConstructorNetworkNode> {
         t.getNode().markDirty();
     });
 
+    public static final TileDataParameter<CompoundNBT, ConstructorTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public ConstructorTile() {
         super(RSTiles.CONSTRUCTOR);
 
         dataManager.addWatchedParameter(COMPARE);
         dataManager.addWatchedParameter(TYPE);
         dataManager.addWatchedParameter(DROP);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -32,4 +45,30 @@ public class ConstructorTile extends NetworkNodeTile<ConstructorNetworkNode> {
     public ConstructorNetworkNode createNode(World world, BlockPos pos) {
         return new ConstructorNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/tile/DestructorTile.java

@@ -2,13 +2,20 @@ package com.refinedmods.refinedstorage.tile;
 
 import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.apiimpl.network.node.DestructorNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.tile.config.IComparable;
 import com.refinedmods.refinedstorage.tile.config.IType;
 import com.refinedmods.refinedstorage.tile.config.IWhitelistBlacklist;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.nbt.CompoundNBT;
 import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
 
 import javax.annotation.Nonnull;
 
@@ -21,6 +28,11 @@ public class DestructorTile extends NetworkNodeTile<DestructorNetworkNode> {
         t.getNode().markDirty();
     });
 
+    public static final TileDataParameter<CompoundNBT, DestructorTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public DestructorTile() {
         super(RSTiles.DESTRUCTOR);
 
@@ -28,6 +40,7 @@ public class DestructorTile extends NetworkNodeTile<DestructorNetworkNode> {
         dataManager.addWatchedParameter(WHITELIST_BLACKLIST);
         dataManager.addWatchedParameter(TYPE);
         dataManager.addWatchedParameter(PICKUP);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -35,4 +48,30 @@ public class DestructorTile extends NetworkNodeTile<DestructorNetworkNode> {
     public DestructorNetworkNode createNode(World world, BlockPos pos) {
         return new DestructorNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/tile/ExporterTile.java

@@ -2,15 +2,29 @@ package com.refinedmods.refinedstorage.tile;
 
 import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.apiimpl.network.node.ExporterNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.tile.config.IComparable;
 import com.refinedmods.refinedstorage.tile.config.IType;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
 
 import javax.annotation.Nonnull;
 
 public class ExporterTile extends NetworkNodeTile<ExporterNetworkNode> {
+
+    public static final TileDataParameter<CompoundNBT, ExporterTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public static final TileDataParameter<Integer, ExporterTile> COMPARE = IComparable.createParameter();
     public static final TileDataParameter<Integer, ExporterTile> TYPE = IType.createParameter();
 
@@ -19,6 +33,7 @@ public class ExporterTile extends NetworkNodeTile<ExporterNetworkNode> {
 
         dataManager.addWatchedParameter(COMPARE);
         dataManager.addWatchedParameter(TYPE);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -26,4 +41,30 @@ public class ExporterTile extends NetworkNodeTile<ExporterNetworkNode> {
     public ExporterNetworkNode createNode(World world, BlockPos pos) {
         return new ExporterNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/tile/ExternalStorageTile.java

@@ -4,12 +4,20 @@ import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.api.storage.AccessType;
 import com.refinedmods.refinedstorage.api.storage.externalstorage.IExternalStorage;
 import com.refinedmods.refinedstorage.apiimpl.network.node.ExternalStorageNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.tile.config.*;
 import com.refinedmods.refinedstorage.tile.data.RSSerializers;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.client.Minecraft;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
 import net.minecraftforge.fluids.FluidStack;
 
 import javax.annotation.Nonnull;
@@ -47,6 +55,11 @@ public class ExternalStorageTile extends NetworkNodeTile<ExternalStorageNetworkN
         return capacity;
     });
 
+    public static final TileDataParameter<CompoundNBT, ExternalStorageTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public ExternalStorageTile() {
         super(RSTiles.EXTERNAL_STORAGE);
 
@@ -57,6 +70,7 @@ public class ExternalStorageTile extends NetworkNodeTile<ExternalStorageNetworkN
         dataManager.addWatchedParameter(CAPACITY);
         dataManager.addWatchedParameter(TYPE);
         dataManager.addWatchedParameter(ACCESS_TYPE);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -64,4 +78,30 @@ public class ExternalStorageTile extends NetworkNodeTile<ExternalStorageNetworkN
     public ExternalStorageNetworkNode createNode(World world, BlockPos pos) {
         return new ExternalStorageNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/tile/ImporterTile.java

@@ -2,12 +2,20 @@ package com.refinedmods.refinedstorage.tile;
 
 import com.refinedmods.refinedstorage.RSTiles;
 import com.refinedmods.refinedstorage.apiimpl.network.node.ImporterNetworkNode;
+import com.refinedmods.refinedstorage.apiimpl.network.node.cover.CoverManager;
 import com.refinedmods.refinedstorage.tile.config.IComparable;
 import com.refinedmods.refinedstorage.tile.config.IType;
 import com.refinedmods.refinedstorage.tile.config.IWhitelistBlacklist;
+import com.refinedmods.refinedstorage.tile.data.TileDataManager;
 import com.refinedmods.refinedstorage.tile.data.TileDataParameter;
+import com.refinedmods.refinedstorage.util.WorldUtils;
+import net.minecraft.client.Minecraft;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.datasync.DataSerializers;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.World;
+import net.minecraftforge.client.model.data.IModelData;
+import net.minecraftforge.client.model.data.ModelDataMap;
 
 import javax.annotation.Nonnull;
 
@@ -16,12 +24,18 @@ public class ImporterTile extends NetworkNodeTile<ImporterNetworkNode> {
     public static final TileDataParameter<Integer, ImporterTile> WHITELIST_BLACKLIST = IWhitelistBlacklist.createParameter();
     public static final TileDataParameter<Integer, ImporterTile> TYPE = IType.createParameter();
 
+    public static final TileDataParameter<CompoundNBT, ImporterTile> COVER_MANAGER = new TileDataParameter<>(DataSerializers.COMPOUND_NBT, new CompoundNBT(),
+            t -> t.getNode().getCoverManager().writeToNbt(),
+            (t, v) -> t.getNode().getCoverManager().readFromNbt(v),
+            (initial, p) -> {});
+
     public ImporterTile() {
         super(RSTiles.IMPORTER);
 
         dataManager.addWatchedParameter(COMPARE);
         dataManager.addWatchedParameter(WHITELIST_BLACKLIST);
         dataManager.addWatchedParameter(TYPE);
+        dataManager.addWatchedParameter(COVER_MANAGER);
     }
 
     @Override
@@ -29,4 +43,30 @@ public class ImporterTile extends NetworkNodeTile<ImporterNetworkNode> {
     public ImporterNetworkNode createNode(World world, BlockPos pos) {
         return new ImporterNetworkNode(world, pos);
     }
+
+    @Nonnull
+    @Override
+    public IModelData getModelData() {
+        return new ModelDataMap.Builder().withInitial(CoverManager.PROPERTY, this.getNode().getCoverManager()).build();
+    }
+
+    @Override
+    public CompoundNBT writeUpdate(CompoundNBT tag) {
+        super.writeUpdate(tag);
+
+        tag.put(CoverManager.NBT_COVER_MANAGER, this.getNode().getCoverManager().writeToNbt());
+
+        return tag;
+    }
+
+    @Override
+    public void readUpdate(CompoundNBT tag) {
+        super.readUpdate(tag);
+
+        this.getNode().getCoverManager().readFromNbt(tag.getCompound(CoverManager.NBT_COVER_MANAGER));
+
+        requestModelDataUpdate();
+
+        WorldUtils.updateBlock(world, pos);
+    }
 }

src/main/java/com/refinedmods/refinedstorage/util/CollisionUtils.java

@@ -19,4 +19,9 @@ public final class CollisionUtils {
             && hit.z >= aabb.minZ
             && hit.z <= aabb.maxZ;
     }
+
+    public static AxisAlignedBB getBounds(int fromX, int fromY, int fromZ, int toX, int toY, int toZ) {
+        return new AxisAlignedBB((float) fromX / 16F, (float) fromY / 16F, (float) fromZ / 16F, (float) toX / 16F, (float) toY / 16F, (float) toZ / 16F);
+    }
+
 }

src/main/java/com/refinedmods/refinedstorage/util/RenderUtils.java

@@ -1,29 +1,46 @@
 package com.refinedmods.refinedstorage.util;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.mojang.blaze3d.matrix.MatrixStack;
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.refinedmods.refinedstorage.api.util.IComparer;
 import com.refinedmods.refinedstorage.apiimpl.API;
 import com.refinedmods.refinedstorage.render.Styles;
 import com.refinedmods.refinedstorage.screen.BaseScreen;
+import net.minecraft.block.BlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.FontRenderer;
 import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.model.BakedQuad;
+import net.minecraft.client.renderer.model.IBakedModel;
+import net.minecraft.client.renderer.model.ItemCameraTransforms;
+import net.minecraft.client.renderer.model.ItemTransformVec3f;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.client.renderer.vertex.VertexFormat;
+import net.minecraft.client.renderer.vertex.VertexFormatElement;
 import net.minecraft.client.util.ITooltipFlag;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.Direction;
 import net.minecraft.util.math.vector.Matrix4f;
+import net.minecraft.util.math.vector.Quaternion;
+import net.minecraft.util.math.vector.TransformationMatrix;
+import net.minecraft.util.math.vector.Vector3f;
 import net.minecraft.util.text.*;
+import net.minecraftforge.client.ForgeHooksClient;
+import net.minecraftforge.client.MinecraftForgeClient;
 import net.minecraftforge.client.event.RenderTooltipEvent;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fml.ModList;
 import net.minecraftforge.fml.client.gui.GuiUtils;
 
 import javax.annotation.Nonnull;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashSet;
+import java.util.function.Consumer;
-import java.util.List;
-import java.util.Set;
 
 public final class RenderUtils {
     private RenderUtils() {
@@ -299,4 +316,102 @@ public final class RenderUtils {
     public static boolean inBounds(int x, int y, int w, int h, double ox, double oy) {
         return ox >= x && ox <= x + w && oy >= y && oy <= y + h;
     }
+
+    public static boolean isLightMapDisabled() {
+        return false;
+    }
+
+    public static VertexFormat getFormatWithLightMap(VertexFormat format) {
+        if (isLightMapDisabled()) {
+            return format;
+        }
+
+        if (format == DefaultVertexFormats.BLOCK) {
+            return DefaultVertexFormats.BLOCK;
+        } else if (!format.hasUV(1)) { ;
+            return new VertexFormat(ImmutableList.<VertexFormatElement>builder().addAll(format.getElements()).add(DefaultVertexFormats.TEX_2S).build());
+        }
+
+        return format;
+    }
+
+    public static TextureAtlasSprite getSprite(IBakedModel coverModel, BlockState coverState, Direction facing, Random rand) {
+        TextureAtlasSprite sprite = null;
+
+        RenderType originalLayer = MinecraftForgeClient.getRenderLayer();
+
+        try {
+            for (RenderType layer : RenderType.getBlockRenderTypes()) {
+                ForgeHooksClient.setRenderLayer(layer);
+
+                for (BakedQuad bakedQuad : coverModel.getQuads(coverState, facing, rand)) {
+                    return bakedQuad.getSprite();
+                }
+
+                for (BakedQuad bakedQuad : coverModel.getQuads(coverState, null, rand)) {
+                    if (sprite == null) {
+                        sprite = bakedQuad.getSprite();
+                    }
+
+                    if (bakedQuad.getFace() == facing) {
+                        return bakedQuad.getSprite();
+                    }
+                }
+            }
+        } catch (Exception e) {
+            // NO OP
+        } finally {
+            ForgeHooksClient.setRenderLayer(originalLayer);
+        }
+
+        if (sprite == null) {
+            try {
+                sprite = coverModel.getParticleTexture();
+            } catch (Exception e) {
+                // NO OP
+            }
+        }
+
+        if (sprite == null) {
+            for (BakedQuad quad : Minecraft.getInstance().getModelManager().getMissingModel().getQuads(coverState, facing, rand)) {
+                return quad.getSprite();
+            }
+        }
+
+        return sprite;
+    }
+
+    private static ImmutableMap<ItemCameraTransforms.TransformType, TransformationMatrix> DEFAULT_BLOCK_TRANSFORM;
+
+    public static ImmutableMap<ItemCameraTransforms.TransformType, TransformationMatrix> getDefaultBlockTransforms() {
+        if (DEFAULT_BLOCK_TRANSFORM != null) {
+            return DEFAULT_BLOCK_TRANSFORM;
+        }
+
+        TransformationMatrix thirdperson = getTransform(0, 2.5f, 0, 75, 45, 0, 0.375f);
+
+        return DEFAULT_BLOCK_TRANSFORM = ImmutableMap.<ItemCameraTransforms.TransformType, TransformationMatrix>builder()
+                .put(ItemCameraTransforms.TransformType.GUI, getTransform(0, 0, 0, 30, 225, 0, 0.625f))
+                .put(ItemCameraTransforms.TransformType.GROUND, getTransform(0, 3, 0, 0, 0, 0, 0.25f))
+                .put(ItemCameraTransforms.TransformType.FIXED, getTransform(0, 0, 0, 0, 0, 0, 0.5f))
+                .put(ItemCameraTransforms.TransformType.THIRD_PERSON_RIGHT_HAND, thirdperson)
+                .put(ItemCameraTransforms.TransformType.THIRD_PERSON_LEFT_HAND, leftifyTransform(thirdperson))
+                .put(ItemCameraTransforms.TransformType.FIRST_PERSON_RIGHT_HAND, getTransform(0, 0, 0, 0, 45, 0, 0.4f))
+                .put(ItemCameraTransforms.TransformType.FIRST_PERSON_LEFT_HAND, getTransform(0, 0, 0, 0, 225, 0, 0.4f))
+                .build();
+    }
+
+    private static TransformationMatrix leftifyTransform(TransformationMatrix transform) {
+        return transform.blockCornerToCenter().blockCenterToCorner();
+    }
+
+    private static TransformationMatrix getTransform(float tx, float ty, float tz, float ax, float ay, float az, float s) {
+        return new TransformationMatrix(
+                new Vector3f(tx / 16, ty / 16, tz / 16),
+                new Quaternion(ax, ay, az, true),
+                new Vector3f(s, s, s),
+                null
+        );
+    }
+
 }

src/main/resources/assets/refinedstorage/lang/en_us.json

@@ -301,6 +301,8 @@
   "item.refinedstorage.security_card": "Security Card",
   "item.refinedstorage.security_card.owner": "Bound to: %s",
   "item.refinedstorage.processor_binding": "Processor Binding",
+  "item.refinedstorage.cover": "Cover",
+  "item.refinedstorage.hollow_cover": "Hollow Cover",
   "commands.refinedstorage.disk.create.error.disk_not_found": "Disk %s was not found.",
   "commands.refinedstorage.disk.create.success": "Successfully gave disk %s to %s.",
   "commands.refinedstorage.network.list.pos": "Network at X: %d, Y: %d, Z: %d",

src/main/resources/data/refinedstorage/recipes/cover.json

@@ -0,0 +1,3 @@
+{
+  "type": "refinedstorage:cover_recipe"
+}

src/main/resources/data/refinedstorage/recipes/hollow_cover.json

@@ -0,0 +1,3 @@
+{
+  "type": "refinedstorage:hollow_cover_recipe"
+}