cable model

src/main/java/org/neoflock/neocomputers/platforms/fabric/client/NeoComputersFabricClient.java

@@ -1,14 +1,17 @@
 package org.neoflock.neocomputers.platforms.fabric.client;
 
 import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.model.loading.v1.ModelLoadingPlugin;
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderers;
 import org.neoflock.neocomputers.entity.BlockEntities;
-import org.neoflock.neocomputers.gui.render.CaseEntityRenderer;
+import org.neoflock.neocomputers.entity.render.CaseEntityRenderer;
-import org.neoflock.neocomputers.gui.render.ScreenEntityRenderer;
+import org.neoflock.neocomputers.entity.render.ScreenEntityRenderer;
+import org.neoflock.neocomputers.platforms.fabric.client.model.ModelLoader;
 
 public class NeoComputersFabricClient implements ClientModInitializer {
     @Override
     public void onInitializeClient() {
+        ModelLoadingPlugin.register(new ModelLoader());
         BlockEntityRenderers.register(BlockEntities.INSTANCE.getSCREEN_ENTITY().get(), ScreenEntityRenderer::new);
         BlockEntityRenderers.register(BlockEntities.INSTANCE.getCASE_ENTITY().get(), CaseEntityRenderer::new);
     }

src/main/java/org/neoflock/neocomputers/platforms/fabric/client/model/CableModel.java

@@ -0,0 +1,138 @@
+//package org.neoflock.neocomputers.platforms.fabric.client.model;
+//
+//import net.fabricmc.fabric.api.renderer.v1.Renderer;
+//import net.fabricmc.fabric.api.renderer.v1.RendererAccess;
+//import net.fabricmc.fabric.api.renderer.v1.mesh.Mesh;
+//import net.fabricmc.fabric.api.renderer.v1.mesh.MeshBuilder;
+//import net.fabricmc.fabric.api.renderer.v1.mesh.MutableQuadView;
+//import net.fabricmc.fabric.api.renderer.v1.mesh.QuadEmitter;
+//import net.fabricmc.fabric.api.renderer.v1.model.FabricBakedModel;
+//import net.fabricmc.fabric.api.renderer.v1.render.RenderContext;
+//import net.minecraft.client.Minecraft;
+//import net.minecraft.client.renderer.block.model.BakedQuad;
+//import net.minecraft.client.renderer.block.model.ItemOverrides;
+//import net.minecraft.client.renderer.block.model.ItemTransforms;
+//import net.minecraft.client.renderer.texture.TextureAtlas;
+//import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+//import net.minecraft.client.resources.model.*;
+//import net.minecraft.core.BlockPos;
+//import net.minecraft.core.Direction;
+//import net.minecraft.resources.ResourceLocation;
+//import net.minecraft.util.RandomSource;
+//import net.minecraft.world.level.BlockAndTintGetter;
+//import net.minecraft.world.level.block.state.BlockState;
+//import org.jetbrains.annotations.Nullable;
+//import org.neoflock.neocomputers.NeoComputers;
+//
+//import java.util.ArrayList;
+//import java.util.Collection;
+//import java.util.List;
+//import java.util.function.Function;
+//import java.util.function.Supplier;
+//
+//// this totally could have been done with datagen, why do i do this
+//public class CableModel implements BakedModel, UnbakedModel, FabricBakedModel {
+////    private TextureAtlasSprite sprite = Minecraft
+////    TextureAtlasSprite sprite = atlas.apply(new Material(TextureAtlas.LOCATION_BLOCKS, ResourceLocation.withDefaultNamespace("block/furnace_top")));
+//
+//    private float MIN = 6/16F;
+//    private float MAX = 10/16F;
+//
+//    private BlockState state;
+//
+//    private Mesh mesh;
+//    @Override
+//    public List<BakedQuad> getQuads(@Nullable BlockState state, @Nullable Direction direction, RandomSource random) {
+////        NeoComputers.INSTANCE.getLOGGER().info("Obtained blockstate!");
+//        this.state = state;
+//        return List.of();
+//    }
+//
+//    @Override
+//    public boolean useAmbientOcclusion() {
+//        return false;
+//    }
+//
+//    @Override
+//    public boolean isGui3d() {
+//        return true;
+//    }
+//
+//    @Override
+//    public boolean usesBlockLight() {
+//        return true;
+//    }
+//
+//    @Override
+//    public boolean isCustomRenderer() {
+//        return false;
+//    }
+//
+//    @Override
+//    public TextureAtlasSprite getParticleIcon() {
+//        Function<ResourceLocation, TextureAtlasSprite> atlas = Minecraft.getInstance().getTextureAtlas(TextureAtlas.LOCATION_BLOCKS);
+//        return atlas.apply(ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "block/teto"));
+//    }
+//
+//    @Override
+//    public ItemTransforms getTransforms() {
+//        return ItemTransforms.NO_TRANSFORMS;
+//    }
+//
+//    @Override
+//    public ItemOverrides getOverrides() {
+//        return ItemOverrides.EMPTY;
+//    }
+//
+//    @Override
+//    public Collection<ResourceLocation> getDependencies() {
+//        return List.of();
+//    }
+//
+//    @Override
+//    public void resolveParents(Function<ResourceLocation, UnbakedModel> resolver) {
+//    }
+//
+//    @Override
+//    public @Nullable BakedModel bake(ModelBaker baker, Function<Material, TextureAtlasSprite> spriteGetter, ModelState state) {
+//        TextureAtlasSprite sprite = spriteGetter.apply(new Material(TextureAtlas.LOCATION_BLOCKS, ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "block/teto")));
+//
+//        Renderer renderer = RendererAccess.INSTANCE.getRenderer();
+//        MeshBuilder builder = renderer.meshBuilder();
+//        QuadEmitter emitter = builder.getEmitter();
+//
+//        bakeCenter(emitter, sprite);
+//
+//
+//        mesh = builder.build();
+//        return this;
+//    }
+//
+//    @Override
+//    public void emitBlockQuads(BlockAndTintGetter blockView, BlockState state, BlockPos pos, Supplier<RandomSource> randomSupplier, RenderContext context) {
+//        mesh.outputTo(context.getEmitter());
+//    }
+//
+//    public void bakeCenter(QuadEmitter emitter, TextureAtlasSprite sprite) {
+//        for (Direction dir : Direction.values()) {
+//            emitter.square(dir, MIN, MIN, MAX, MAX, MIN);
+//            emitter.spriteBake(sprite, MutableQuadView.BAKE_LOCK_UV);
+//            emitter.color(-1, -1, -1, -1);
+//            emitter.emit();
+//        }
+//    }
+//    public void bakeConnection(Direction dir, QuadEmitter emitter, TextureAtlasSprite sprite) {
+//        int mag = dir.getStepX()+dir.getStepZ(); // i dont want to hear it
+//        float bottom = dir.getStepY()==0 ? 6/16F : (dir.getStepY()==1 ? 10/16F : 0F);
+//
+//        for (Direction d : dir.getAxis().getPlane().faces) {
+//            emitter.square(d, (6/16F)+0.5F*mag, bottom, 6/16F)
+//        }
+//
+//    }
+//
+////    @Override
+////    public boolean isVanillaAdapter() {
+////        return false; // TODO: let this be true so maybe forge and fabric can be unified
+////    }
+//}

src/main/java/org/neoflock/neocomputers/platforms/fabric/client/model/ModelLoader.java

@@ -0,0 +1,25 @@
+package org.neoflock.neocomputers.platforms.fabric.client.model;
+
+import net.fabricmc.fabric.api.client.model.loading.v1.ModelLoadingPlugin;
+import net.minecraft.client.resources.model.ModelResourceLocation;
+import net.minecraft.resources.ResourceLocation;
+import org.neoflock.neocomputers.NeoComputers;
+
+public class ModelLoader implements ModelLoadingPlugin {
+    public static final ResourceLocation CABLE = ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, "cable");
+
+    @Override
+    public void onInitializeModelLoader(Context pluginContext) {
+        pluginContext.modifyModelOnLoad().register((original, context) -> {
+//           final ModelResourceLocation id = context.topLevelId();
+////           if (id != null && id.id().getNamespace().equals(NeoComputers.MODID)) NeoComputers.INSTANCE.getLOGGER().info("{} {} {}", id.id().getNamespace(), id.id().getPath(), id.id().getPath().equals(CABLE.id().getPath()));
+//           if (id != null && id.id().equals(CABLE)) {
+////               NeoComputers.INSTANCE.getLOGGER().error("DOING CABLEEEEEEE");
+//               return new CableModel();
+//           } else {
+//               return original;
+//           }
+            return original;
+        });
+    }
+}

src/main/kotlin/org/neoflock/neocomputers/block/Blocks.kt

@@ -33,6 +33,7 @@ object Blocks {
     val COMBUSTGEN_BLOCK: RegistrySupplier<Block> = BaseBlock.register("combustgen") { CombustionGeneratorBlock() }
     val CASE_BLOCK: RegistrySupplier<Block> = BaseBlock.register("case") { CaseBlock() }
     val REDSTONEIO_BLOCK: RegistrySupplier<Block> = BaseBlock.register("redio") { RedstoneIOBlock() }
+    val CABLE_BLOCK: RegistrySupplier<Block> = BaseBlock.register("cable") { CableBlock() }
 
     fun registerBlockItems() {
         BLOCKS.forEach(Consumer { sup: RegistrySupplier<Block> ->

src/main/kotlin/org/neoflock/neocomputers/block/CableBlock.kt

@@ -0,0 +1,115 @@
+package org.neoflock.neocomputers.block
+
+import net.minecraft.client.renderer.blockentity.PistonHeadRenderer
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.EntityBlock
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BooleanProperty
+import net.minecraft.world.phys.shapes.BooleanOp
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+import org.neoflock.neocomputers.entity.CableEntity
+
+class CableBlock() : BaseBlock(Properties.of()), EntityBlock {
+    companion object {
+        val NORTH = BooleanProperty.create("north")
+        val EAST = BooleanProperty.create("east")
+        val WEST = BooleanProperty.create("west")
+        val SOUTH = BooleanProperty.create("south")
+        val UP = BooleanProperty.create("up")
+        val DOWN = BooleanProperty.create("down")
+
+        val MIN = 0.375
+        val MAX = 1-MIN
+
+//        val shapeCache: Array<VoxelShape?> = arrayOfNulls(Direction.entries.size*Direction.entries.size*Direction.entries.size*Direction.entries.size*Direction.entries.size*Direction.entries.size)
+//
+//        fun makeShapes() { // screw perf
+//            for (north in arrayOf(false, true)) { // shut up
+//                for (east in arrayOf(false, true)) {
+//                    for (west in arrayOf(false, true)) {
+//                        for (south in arrayOf(false, true)) {
+//                            for (up in arrayOf(false, true)) {
+//                                for (down in arrayOf(false, true)) {
+//                                    val shape = makeShape(north, south, east, west, up, down)
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+
+        fun makeShape(north: Boolean, south: Boolean, east: Boolean, west: Boolean, up: Boolean, down: Boolean): VoxelShape {
+            var shape = Shapes.box(MIN, MIN, MIN, MAX, MAX, MAX)
+            if (north) shape = Shapes.join(shape, Shapes.box(MIN, MIN, 0.0, MAX, MAX, MIN ), BooleanOp.OR)
+            if (south) shape = Shapes.join(shape, Shapes.box(MIN, MIN, MAX, MAX, MAX, 1.0 ), BooleanOp.OR)
+            if (east) shape = Shapes.join(shape, Shapes.box(MAX, MIN, MIN, 1.0, MAX, MAX), BooleanOp.OR)
+            if (west) shape = Shapes.join(shape, Shapes.box(0.0, MIN, MIN, MIN, MAX, MAX ), BooleanOp.OR)
+            if (up) shape = Shapes.join(shape, Shapes.box(MIN, MAX, MIN, MAX, 1.0, MAX), BooleanOp.OR)
+            if (down) shape = Shapes.join(shape, Shapes.box(MIN, 0.0, MIN, MAX, MIN, MAX ), BooleanOp.OR)
+            return shape
+        }
+
+        fun getPropByDirection(direction: Direction): BooleanProperty {
+            return when (direction) {
+                Direction.NORTH -> NORTH
+                Direction.SOUTH -> SOUTH
+                Direction.WEST -> WEST
+                Direction.EAST -> EAST
+                Direction.UP -> UP
+                Direction.DOWN -> DOWN
+            }
+        }
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(NORTH, false)
+            .setValue(EAST, false)
+            .setValue(WEST, false)
+            .setValue(SOUTH, false)
+            .setValue(UP, false)
+            .setValue(DOWN, false)
+        )
+    }
+
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block?, BlockState?>) {
+        super.createBlockStateDefinition(builder
+            .add(NORTH)
+            .add(EAST)
+            .add(SOUTH)
+            .add(WEST)
+            .add(UP)
+            .add(DOWN))
+    }
+
+    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity? {
+        return CableEntity(pos, state)
+    }
+
+    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape? {
+        return makeShape(state.getValue(NORTH), state.getValue(SOUTH), state.getValue(EAST), state.getValue(WEST), state.getValue(UP), state.getValue(DOWN))
+    }
+
+    override fun neighborChanged(state: BlockState, level: Level, pos: BlockPos, neighborBlock: Block, neighborPos: BlockPos, movedByPiston: Boolean) {
+//        val neighbors = getNeighbourEntities(blockPos, level)
+//        for (dir in Direction.entries) {
+//            val ent = level.getBlockEntity(blockPos.relative(dir))
+//            level.setBlockAndUpdate(blockPos, blockState.setValue(getPropByDirection(dir), (ent is NodeBlockEntity || ent is CableEntity)))
+//        }
+        val diff = pos.subtract(neighborPos)
+        val dir = Direction.fromDelta(diff.x, diff.y, diff.z)!!.opposite
+        val ent = level.getBlockEntity(neighborPos)
+        val value = ent is NodeBlockEntity || ent is CableEntity
+        level.setBlockAndUpdate(pos, state.setValue(getPropByDirection(dir), value))
+    }
+}

src/main/kotlin/org/neoflock/neocomputers/entity/BlockEntities.kt

@@ -42,42 +42,48 @@ object BlockEntities {
 
     val SCREEN_ENTITY: RegistrySupplier<BlockEntityType<ScreenEntity>> = BLOCKENTITIES.register("screen") {
         BlockEntityType(
-            ::ScreenEntity, mutableSetOf(Blocks.SCREEN_BLOCK.get()), BullshitFix()
+            ::ScreenEntity, setOf(Blocks.SCREEN_BLOCK.get()), BullshitFix()
         )
     }
     val CAPACITOR_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntityTier1>> = BLOCKENTITIES.register("capacitor") {
         BlockEntityType(
-            ::CapacitorEntityTier1, mutableSetOf(Blocks.CAPACITOR_BLOCK.get()), BullshitFix()
+            ::CapacitorEntityTier1, setOf(Blocks.CAPACITOR_BLOCK.get()), BullshitFix()
         )
     }
     val CAPACITOR2_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntityTier2>> = BLOCKENTITIES.register("capacitor2") {
         BlockEntityType(
-            ::CapacitorEntityTier2, mutableSetOf(Blocks.CAPACITOR_BLOCK2.get()), BullshitFix()
+            ::CapacitorEntityTier2, setOf(Blocks.CAPACITOR_BLOCK2.get()), BullshitFix()
         )
     }
     val CAPACITOR3_ENTITY: RegistrySupplier<BlockEntityType<CapacitorEntityTier3>> = BLOCKENTITIES.register("capacitor3") {
         BlockEntityType(
-            ::CapacitorEntityTier3, mutableSetOf(Blocks.CAPACITOR_BLOCK3.get()), BullshitFix()
+            ::CapacitorEntityTier3, setOf(Blocks.CAPACITOR_BLOCK3.get()), BullshitFix()
         )
     }
     val SOLARGEN_ENTITY: RegistrySupplier<BlockEntityType<SolarGeneratorBlockEntity>> = BLOCKENTITIES.register("solargen") {
         BlockEntityType(
-            ::SolarGeneratorBlockEntity, mutableSetOf(Blocks.SOLARGEN_BLOCK.get()), BullshitFix()
+            ::SolarGeneratorBlockEntity, setOf(Blocks.SOLARGEN_BLOCK.get()), BullshitFix()
         )
     }
     val COMBUSTGEN_ENTITY: RegistrySupplier<BlockEntityType<CombustionGeneratorBlockEntity>> = BLOCKENTITIES.register("combustgen") {
         BlockEntityType(
-            ::CombustionGeneratorBlockEntity, mutableSetOf(Blocks.COMBUSTGEN_BLOCK.get()), BullshitFix()
+            ::CombustionGeneratorBlockEntity, setOf(Blocks.COMBUSTGEN_BLOCK.get()), BullshitFix()
         )
     }
     val REDSTONEIO_ENTITY: RegistrySupplier<BlockEntityType<CombustionGeneratorBlockEntity>> = BLOCKENTITIES.register("redio") {
         BlockEntityType(
-            ::CombustionGeneratorBlockEntity, mutableSetOf(Blocks.REDSTONEIO_BLOCK.get()), BullshitFix()
+            ::CombustionGeneratorBlockEntity, setOf(Blocks.REDSTONEIO_BLOCK.get()), BullshitFix()
         )
     }
     val CASE_ENTITY: RegistrySupplier<BlockEntityType<CaseBlockEntity>> = BLOCKENTITIES.register("case") {
         BlockEntityType(
-            ::CaseBlockEntity, mutableSetOf(Blocks.CASE_BLOCK.get()), BullshitFix()
+            ::CaseBlockEntity, setOf(Blocks.CASE_BLOCK.get()), BullshitFix()
+        )
+    }
+
+    val CABLE_ENTITY: RegistrySupplier<BlockEntityType<CableEntity>> = BLOCKENTITIES.register("cable") {
+        BlockEntityType(
+            ::CableEntity, setOf(Blocks.CABLE_BLOCK.get()), BullshitFix()
         )
     }
 

src/main/kotlin/org/neoflock/neocomputers/entity/CableEntity.kt

@@ -0,0 +1,34 @@
+package org.neoflock.neocomputers.entity
+
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import org.neoflock.neocomputers.block.CableBlock
+import org.neoflock.neocomputers.block.NodeBlockEntity
+
+class CableEntity(pos: BlockPos, state: BlockState) : BlockEntity(BlockEntities.CABLE_ENTITY.get(), pos, state) {
+
+    override fun setChanged() {
+        super.setChanged()
+//        val neighbors = getNeighbourEntities()
+
+        for (dir in Direction.entries) {
+            val ent = level!!.getBlockEntity(blockPos.relative(dir))
+            level!!.setBlockAndUpdate(blockPos, blockState.setValue(CableBlock.getPropByDirection(dir), (ent is NodeBlockEntity || ent is CableEntity)))
+        }
+
+    }
+//    fun getNeighbourEntities(): List<BlockEntity> {
+//        val subpos = listOf(
+//            blockPos.offset(0, 0, 1),
+//            blockPos.offset(0, 0, -1),
+//            blockPos.offset(0, 1, 0),
+//            blockPos.offset(0, -1, 0),
+//            blockPos.offset(1, 0, 0),
+//            blockPos.offset(-1, 0, 0),
+//        )
+//
+//        return subpos.mapNotNull { pos -> level?.getBlockEntity(pos) }
+//    }
+}

src/main/kotlin/org/neoflock/neocomputers/entity/ScreenEntity.kt

@@ -72,7 +72,7 @@ class ScreenEntity(blockPos: BlockPos, blockState: BlockState) :
 
     private fun createscreenstuffs() {
         bound = "screen/"+node.address.toString().replace("-", "_")
-        NeoComputers.LOGGER.info(bound)
+//        NeoComputers.LOGGER.info(bound)
         if (level!!.isClientSide) {
             var renderer = BufferRenderer(ResourceLocation.fromNamespaceAndPath(NeoComputers.MODID, bound), textBuf)
             renderer.drawBuffer()

src/main/kotlin/org/neoflock/neocomputers/entity/render/CaseEntityRenderer.kt

@@ -1,4 +1,4 @@
-package org.neoflock.neocomputers.gui.render
+package org.neoflock.neocomputers.entity.render
 
 import com.mojang.blaze3d.vertex.DefaultVertexFormat
 import com.mojang.blaze3d.vertex.PoseStack
@@ -11,11 +11,11 @@ import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderer
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider
 import net.minecraft.core.Direction
-import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.block.CaseBlock
 import org.neoflock.neocomputers.entity.CaseBlockEntity
 
-class CaseEntityRenderer(private val context: BlockEntityRendererProvider.Context?) : BlockEntityRenderer<CaseBlockEntity>{
+class CaseEntityRenderer(private val context: BlockEntityRendererProvider.Context?) :
+    BlockEntityRenderer<CaseBlockEntity> {
 
     val OFF = 0xFF5F855E.toInt()
     val GREEN = 0xFF4EDC5E.toInt()

src/main/kotlin/org/neoflock/neocomputers/entity/render/ScreenEntityRenderer.kt

@@ -1,26 +1,20 @@
-package org.neoflock.neocomputers.gui.render
+package org.neoflock.neocomputers.entity.render
 
-import com.mojang.blaze3d.systems.RenderSystem
 import com.mojang.blaze3d.vertex.DefaultVertexFormat
 import com.mojang.blaze3d.vertex.PoseStack
-import com.mojang.blaze3d.vertex.VertexConsumer
 import com.mojang.blaze3d.vertex.VertexFormat
 import com.mojang.math.Axis
-import net.minecraft.client.renderer.GameRenderer
 import net.minecraft.client.renderer.MultiBufferSource
 import net.minecraft.client.renderer.RenderStateShard
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.blockentity.BlockEntityRenderer
 import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider
-import net.minecraft.client.renderer.blockentity.ChestRenderer
 import net.minecraft.core.Direction
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.world.level.block.state.properties.EnumProperty
 import org.neoflock.neocomputers.NeoComputers
 import org.neoflock.neocomputers.block.ScreenBlock
 import org.neoflock.neocomputers.entity.ScreenEntity
 
-
 class ScreenEntityRenderer(val context: BlockEntityRendererProvider.Context?) : BlockEntityRenderer<ScreenEntity> { // TODO: FORGE
     val RENDER_TYPE: (ResourceLocation) -> RenderType = { t: ResourceLocation ->
         RenderType.create(

src/main/resources/assets/neocomputers/blockstates/cable.json

@@ -0,0 +1,94 @@
+{
+    "multipart": [
+        { "apply":  { "model":  "neocomputers:block/cable/cable_center" }},
+        { "when":  { "south":  true },
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection" }},
+        { "when":  { "east":  true},
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection", "y": -90}},
+        { "when":  { "west":  true },
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection", "y": 90}},
+        { "when":  { "north":  true },
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection", "y": 180}},
+        { "when":  { "up":  true },
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection", "x": 90}},
+        { "when":  { "down":  true },
+        "apply":  { "model":  "neocomputers:block/cable/cable_connection", "x": -90}},
+        {
+            "when": {
+                "south":  false,
+                "north":  false,
+                "east":  false,
+                "west":  false,
+                "up":  false,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_caps" }
+        },
+        {
+            "when": {
+                "south":  true,
+                "north":  false,
+                "east":  false,
+                "west":  false,
+                "up":  false,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap" }
+        },
+        {
+            "when": {
+                "south":  false,
+                "north":  true,
+                "east":  false,
+                "west":  false,
+                "up":  false,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap", "y": 180 }
+        },
+        {
+            "when": {
+                "south":  false,
+                "north":  false,
+                "east":  true,
+                "west":  false,
+                "up":  false,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap", "y": -90 }
+        },
+        {
+            "when": {
+                "south":  false,
+                "north":  false,
+                "east":  false,
+                "west":  true,
+                "up":  false,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap", "y": 90 }
+        },
+        {
+            "when": {
+                "south":  false,
+                "north":  false,
+                "east":  false,
+                "west":  false,
+                "up":  true,
+                "down":  false
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap", "x": 90 }
+        },
+        {
+            "when": {
+                "south":  false,
+                "north":  false,
+                "east":  false,
+                "west":  false,
+                "up":  false,
+                "down":  true
+            },
+            "apply": { "model":  "neocomputers:block/cable/cable_cap", "x": -90 }
+        }
+    ]
+}

src/main/resources/assets/neocomputers/models/block/cable/cable_cap.json

@@ -0,0 +1,21 @@
+{
+  "parent": "minecraft:block/block",
+  "render_type": "minecraft:solid",
+  "textures": {
+    "cap": "neocomputers:block/cable_cap"
+  },
+  "elements": [
+    {
+      "from": [6, 6, 5],
+      "to": [10, 10, 6],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [6, 6, 10, 10], "texture": "#cap"}
+      }
+    }
+  ]
+}
+

src/main/resources/assets/neocomputers/models/block/cable/cable_caps.json

@@ -0,0 +1,81 @@
+{
+  "parent": "minecraft:block/block",
+  "render_type": "minecraft:solid",
+  "textures": {
+    "cap": "neocomputers:block/cable_cap"
+  },
+  "elements": [
+    {
+      "from": [6, 6, 5],
+      "to": [10, 10, 6],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [6,6,10,10], "texture": "#cap"},
+        "south": { "uv":  [0,0,4,4], "texture":  "#cap"}
+      }
+    },
+    {
+      "from": [6, 6, 10],
+      "to": [10, 10, 11],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"},
+        "south": { "uv":  [6,6,10,10], "texture":  "#cap"}
+      }
+    },
+    {
+      "from": [5, 6, 6],
+      "to": [6, 10, 10],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [6,6,10,10], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"},
+        "south": { "uv":  [0,0,4,4], "texture":  "#cap"}
+      }
+    },
+    {
+      "from": [10, 6, 6],
+      "to": [11, 10, 10],
+      "faces": {
+        "east": { "uv":  [6,6,10,10], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"},
+        "south": { "uv":  [0,0,4,4], "texture":  "#cap"}
+      }
+    },
+    {
+      "from": [6, 5, 6],
+      "to": [10, 6, 10],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [6,6,10,10], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"},
+        "south": { "uv":  [0,0,4,4], "texture":  "#cap"}
+      }
+    },
+    {
+      "from": [6, 10, 6],
+      "to": [10, 11, 10],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [6,6,10,10], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"},
+        "south": { "uv":  [0,0,4,4], "texture":  "#cap"}
+      }
+    }
+  ]
+}

src/main/resources/assets/neocomputers/models/block/cable/cable_center.json

@@ -0,0 +1,21 @@
+{
+    "parent": "minecraft:block/block",
+    "render_type": "minecraft:solid",
+    "textures": {
+        "cap": "neocomputers:block/cable_body"
+    },
+    "elements": [
+        {
+            "from": [6, 6, 6],
+            "to": [10, 10, 10],
+            "faces": {
+                "north": { "uv":  [6,6,10,10], "texture": "#cap" },
+                "east": { "uv":  [6,6,10,10], "texture": "#cap" },
+                "west": { "uv":  [6,6,10,10], "texture": "#cap" },
+                "south": { "uv":  [6,6,10,10], "texture": "#cap" },
+                "up": { "uv":  [0,0, 5, 5], "texture": "#cap" },
+                "down": { "uv":  [0,0, 5, 5], "texture": "#cap" }
+            }
+        }
+    ]
+}

src/main/resources/assets/neocomputers/models/block/cable/cable_connection.json

@@ -0,0 +1,21 @@
+{
+    "parent": "minecraft:block/block",
+    "render_type": "minecraft:solid",
+    "textures": {
+        "cap": "neocomputers:block/cable_cap",
+        "body": "neocomputers:block/cable_body"
+    },
+    "elements": [
+        {
+            "from": [6, 6, 10],
+            "to": [10, 10, 16],
+            "faces": {
+                "east": { "uv":  [4,4,11,11], "texture": "#body" },
+                "west": { "uv":  [4,4,11,11], "texture": "#body" },
+                "up": { "uv":  [4,4,11,11], "texture": "#body" },
+                "down": { "uv":  [4,4,11,11], "texture": "#body" },
+                "south": { "uv":  [6, 6, 10, 10], "texture": "#cap"}
+            }
+        }
+    ]
+}

src/main/resources/assets/neocomputers/models/block/cable/cable_item.json

@@ -0,0 +1,44 @@
+{
+  "parent": "minecraft:block/block",
+  "render_type": "minecraft:solid",
+  "textures": {
+    "cap": "neocomputers:block/cable_cap",
+    "body": "neocomputers:block/cable_body"
+  },
+  "elements": [
+    {
+      "from": [6, -2, 6],
+      "to": [10, 18, 10],
+      "faces": {
+        "east": { "uv":  [0,0,5,16], "texture": "#body" },
+        "west": { "uv":  [0,0,5,16], "texture": "#body" },
+        "north": { "uv":  [0,0,5,16], "texture": "#body" },
+        "south": { "uv":  [0,0,5,16], "texture": "#body" },
+        "up": { "uv":  [0,0,5,16], "texture": "#body" },
+        "down": { "uv":  [0,0,5,16], "texture": "#body" }
+      }
+    },
+    {
+      "from": [4, -3, 4],
+      "to": [12, -2, 12],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "down": { "uv":  [4, 4, 12, 12], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"}
+      }
+    },
+    {
+      "from": [4, 18, 4],
+      "to": [12, 19, 12],
+      "faces": {
+        "east": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "west": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "up": { "uv":  [4, 4, 12, 12], "texture": "#cap" },
+        "down": { "uv":  [0,0,4,4], "texture": "#cap" },
+        "north": { "uv":  [0,0,4,4], "texture": "#cap"}
+      }
+    }
+  ]
+}

src/main/resources/assets/neocomputers/models/item/cable.json

@@ -0,0 +1,3 @@
+{
+  "parent": "neocomputers:block/cable/cable_item"
+}

src/main/resources/neocomputers.accesswidener

@@ -1,3 +1,4 @@
 accessWidener v2 named
 
 accessible method net/minecraft/world/level/block/entity/BlockEntityType <init> (Lnet/minecraft/world/level/block/entity/BlockEntityType$BlockEntitySupplier;Ljava/util/Set;)V
+accessible field net/minecraft/core/Direction$Plane faces [Lnet/minecraft/core/Direction;